Session keys

import { Keypair } from '@solana/web3.js';

/**
 * Generate it here. **WRITE THE SECRET BEFORE YOU SEND THE AUTHORISATION** — step 2 — and
 * remove it only on a decoded REFUSAL, never on an unknown. See the warning below; this is
 * not a preference.
 *
 * Scope the storage to the session and clear it on logout, at which point you also call
 * `endSession` (step 4). A session key in durable storage outlives the trader's intent.
 */
export const sessionKey = Keypair.generate();

import { Connection, Keypair, PublicKey, Transaction } from '@solana/web3.js';
import {
  DEFAULT_SESSION_TERMS,
  authorizeSession,
  configPda,
  delegatePda,
  ourInstruction,
  toHex,
} from '@rekt/1000x';

export async function authorise(args: {
  connection: Connection;
  owner: PublicKey;
  /** The trader's own USDC account. The allowance is written against THIS account. */
  traderToken: PublicKey;
  sessionKey: Keypair;
  /** How much this session may spend in total before it must be renewed. */
  allowance: bigint;
  sign: (tx: Transaction) => Promise<Transaction>;
}): Promise<string> {
  const built = authorizeSession({
    owner: toHex(args.owner),
    delegateKey: toHex(args.sessionKey.publicKey),
    delegate: toHex(delegatePda(args.owner).address),
    traderToken: toHex(args.traderToken),
    // Required: the program reads the governed maximum stake off the config account.
    config: toHex(configPda().address),
    // 24 hours, a 24-hour spend window, and the window's ceiling. Override deliberately.
    terms: DEFAULT_SESSION_TERMS,
    // Required — `SessionArgs.restrictions` is a `number` with no `?`, so omitting it is a
    // build error. `0` grants Close and Retarget only, NOT LP; `DELEGATE_NO_CLOSE` withholds the
    // close, and `DELEGATE_ALLOW_LP` (opt-in) adds the LP triggers.
    restrictions: 0,
    // The SPL allowance is a TOTAL that draws down and never refills. Size it for how long
    // the trader means to be at the desk; the window limit only bounds the rate.
    allowance: args.allowance,
  });

  const tx = new Transaction().add(...built.map(ourInstruction));
  tx.feePayer = args.owner;
  tx.recentBlockhash = (await args.connection.getLatestBlockhash('confirmed')).blockhash;

  // The ONE wallet prompt in the whole arrangement. The trader may take as long as they like
  // reading it.
  const signed = await args.sign(tx);

  // STORE THE SECRET HERE, before the send — not after a confirmation. See step 1.
  // On a refusal you can delete it. On a timeout you cannot know, and the branch where it
  // landed is the expensive one.
  persistSessionSecret(args.owner, args.sessionKey.secretKey);

  return args.connection.sendRawTransaction(signed.serialize());
}

import { LAMPORTS_PER_SOL, PublicKey, SystemProgram, Transaction } from '@solana/web3.js';

/**
 * Enough SOL for the session's own transaction fees. Send it alongside the authorisation so a
 * trader signs once for both.
 *
 * Return the remainder to the owner when you revoke — a session key that keeps a dust balance
 * after logout is a wallet nobody is watching.
 */
export function fundSession(owner: PublicKey, sessionKey: PublicKey, sol = 0.01): Transaction {
  return new Transaction().add(
    SystemProgram.transfer({
      fromPubkey: owner,
      toPubkey: sessionKey,
      lamports: BigInt(Math.round(sol * LAMPORTS_PER_SOL)),
    }),
  );
}

import {
  ComputeBudgetProgram,
  Connection,
  Keypair,
  PublicKey,
  TransactionMessage,
  VersionedTransaction,
} from '@solana/web3.js';
import {
  assetId,
  computeUnitLimit,
  configPda,
  delegatePda,
  ix,
  marketPda,
  ourInstruction,
  priceAccountsFor,
  toHex,
  traderPda,
  vaultPda,
  type ConfigView,
  type MarketView,
} from '@rekt/1000x';

export async function openWithSession(args: {
  connection: Connection;
  config: ConfigView;
  symbol: string;
  market: MarketView;
  /** The trader. Signs NOTHING here. */
  owner: PublicKey;
  /** The session. Signs and pays. */
  sessionKey: Keypair;
  traderToken: PublicKey;
  vaultToken: PublicKey;
  protocolToken: PublicKey;
  /** The fee-inclusive TOTAL to spend. The debit is at most this. */
  budget: bigint;
  direction: 'long' | 'short';
  rungBps: number;
  userTimerS: number;
  /** The mandatory floor on the position SIZE — `sizeForTotal(budget, config.params).collateral`.
   *  `0n` is refused (`MinCollateralOutRequired`). */
  minCollateralOut: bigint;
  /** A durable key you choose, or `0n`. Read by nothing on chain. */
  openerTag: bigint;
}): Promise<string> {
  const built = ix.open(
    {
      // Whoever signs. With a session that is the session key, not the owner.
      authority: toHex(args.sessionKey.publicKey),
      trader_token: toHex(args.traderToken),
      config: toHex(configPda().address),
      market: toHex(marketPda(assetId(args.symbol)).address),
      vault: toHex(vaultPda().address),
      vault_token: toHex(args.vaultToken),
      protocol_token: toHex(args.protocolToken),
      // The OWNER's book, always. The session never gets one of its own.
      positions: toHex(traderPda(args.owner).address),
      // `null` here with a signer who is not the owner is refused by the program, so this
      // cannot be used to open against somebody else's book.
      delegate: toHex(delegatePda(args.owner).address),
    },
    {
      // Fee-inclusive TOTAL; the venue takes its fee from inside it.
      budget: args.budget,
      direction: args.direction === 'long' ? 0 : 1,
      rung_bps: args.rungBps,
      user_timer_s: args.userTimerS,
      // Mandatory floor on the position SIZE. Set it to `sizeForTotal`'s predicted collateral,
      // never a token value; `0n` is refused.
      min_collateral_out: args.minCollateralOut,
      referrer: null,
      // `0` is the market's own tier — see `/sdk/opening`. A session key may name a lower
      // leverage exactly as the owner may; the delegate checks authorise the SIGNER, and the
      // tier is a property of the trade.
      tier: 0,
      // A durable key you choose, read by nothing on chain. `0n` is the absence.
      opener_tag: args.openerTag,
    },
    // The market's fee-terms account when it has terms. An order carries no quote.
    priceAccountsFor(args.market, args.config, 'open'),
  );

  const { blockhash } = await args.connection.getLatestBlockhash('confirmed');
  const message = new TransactionMessage({
    // The session pays. An owner fee payer means an owner signature means a wallet prompt.
    payerKey: args.sessionKey.publicKey,
    recentBlockhash: blockhash,
    instructions: [
      ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnitLimit('open', { quotePost: false }) }),
      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1_000 }),
      ourInstruction(built),
    ],
  }).compileToV0Message();
  const tx = new VersionedTransaction(message);
  tx.sign([args.sessionKey]);
  // Simulate first, as on /sdk/opening: a refusal costs nothing and arrives as a name.
  const sim = await args.connection.simulateTransaction(tx, { commitment: 'confirmed' });
  if (sim.value.err !== null) throw new Error(JSON.stringify(sim.value.err));
  return args.connection.sendTransaction(tx);
}

import { Connection, PublicKey, Transaction } from '@solana/web3.js';
import { decodeTradeDelegate, delegatePda, endSession, ourInstruction, toHex } from '@rekt/1000x';

export async function revoke(args: {
  connection: Connection;
  owner: PublicKey;
  sign: (tx: Transaction) => Promise<Transaction>;
}): Promise<string | null> {
  const address = delegatePda(args.owner).address;
  const info = await args.connection.getAccountInfo(address, 'confirmed');
  // No account is not an error — it is a trader with no session, which is the goal state.
  if (!info) return null;

  const delegate = decodeTradeDelegate(new Uint8Array(info.data));

  const built = endSession({
    owner: toHex(args.owner),
    delegate: toHex(address),
    // MUST be the account the allowance was granted over. `TradeDelegate.tokenAccount` is
    // pinned by the chain — read it rather than re-deriving the trader's associated token
    // account and hoping the two agree.
    traderToken: delegate.tokenAccount,
  });

  const tx = new Transaction().add(...built.map(ourInstruction));
  tx.feePayer = args.owner;
  tx.recentBlockhash = (await args.connection.getLatestBlockhash('confirmed')).blockhash;
  const signed = await args.sign(tx);
  return args.connection.sendRawTransaction(signed.serialize());
}