Create a session

import { definePermissions } from "@rhinestone/1auth";
import { erc20Abi, parseUnits, type Address } from "viem";

const targetChain = 84532;
// Replace these placeholders with addresses on the target chain.
const token = "0x..." as Address;
const recipient = "0x..." as Address;
const maxAmountPerTransfer = parseUnits("10", 6);
const validAfter = Math.floor(Date.now() / 1000);
const validUntil = validAfter + 24 * 60 * 60;

const transferPermission = definePermissions({
  address: token,
  name: "Token",
  abi: erc20Abi,
  functions: {
    transfer: {
      params: {
        recipient: { condition: "equal", value: recipient },
        amount: {
          condition: "lessThanOrEqual",
          value: maxAmountPerTransfer,
        },
      },
    },
  },
});

import { oneAuth } from "./oneauth";

const grant = await oneAuth.grantPermissions({
  accountAddress,
  targetChains: [targetChain],
  sessionKeyAddress,
  validAfter,
  validUntil,
  maxUses: 25,
  ...transferPermission,
});

if (!grant.success || !grant.grantId || !grant.sessionKeyHandle) {
  throw new Error(grant.error?.message ?? "Permission grant failed");
}

import {
  buildSmartSessionHeadlessSignatures,
  OneAuthHeadlessClient,
  type SessionKeyHandle,
} from "@rhinestone/1auth/headless";
import {
  encodeFunctionData,
  erc20Abi,
  parseUnits,
  type Address,
  type Hex,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { sponsorship } from "./sponsorship";

const rawSession = sessionStorage.getItem(
  `session:${accountAddress.toLowerCase()}`,
);
if (!rawSession) throw new Error("No session stored for this account");

const saved = JSON.parse(rawSession) as {
  grantId: string;
  accountAddress: Address;
  sessionKeyAddress: Address;
  privateKey: Hex;
  handle: SessionKeyHandle;
};

const sameAddress = (left: Address, right: Address) =>
  left.toLowerCase() === right.toLowerCase();
const signerAddress = privateKeyToAccount(saved.privateKey).address;

if (
  !sameAddress(saved.accountAddress, accountAddress) ||
  !sameAddress(saved.handle.accountAddress, accountAddress) ||
  !sameAddress(saved.sessionKeyAddress, signerAddress) ||
  !sameAddress(saved.handle.sessionKeyAddress, signerAddress)
) {
  throw new Error("Stored session does not match this account and signer");
}

const rpId = oneAuth.getWebAuthnRpId();
const headless = new OneAuthHeadlessClient({
  providerUrl: oneAuth.getProviderUrl(),
  clientId: oneAuth.getClientId(),
  webauthn: {
    mode: "app_origin",
    ...(rpId ? { rpId } : {}),
  },
  sponsorship,
});

const prepared = await headless.prepareIntent({
  accountAddress,
  targetChain,
  calls: [
    {
      to: token,
      value: 0n,
      data: encodeFunctionData({
        abi: erc20Abi,
        functionName: "transfer",
        args: [recipient, parseUnits("5", 6)],
      }),
    },
  ],
  sessionKeyHandle: saved.handle,
});

const signatures = await buildSmartSessionHeadlessSignatures({
  privateKey: saved.privateKey,
  accountAddress: prepared.accountAddress,
  sessionKeyHandle: saved.handle,
  prepared,
});

const submitted = await headless.submitIntent({
  intentOp: prepared.intentOp,
  digestResult: prepared.digestResult,
  binding: prepared.binding,
  accountAddress: prepared.accountAddress,
  targetChain: prepared.targetChain,
  calls: prepared.calls,
  expiresAt: prepared.expiresAt,
  sponsorshipMode: prepared.sponsorshipMode ?? "self-funded",
  ...signatures,
});

if (!submitted.success) {
  throw new Error("Headless submission failed");
}

const final = await headless.waitForIntent(
  submitted.intentId,
  submitted.transactionResult,
);