@glideco/recovery

npm install @glideco/recovery

import {
  composeEnableRecoveryModuleCalls,
  RECOVERY_COOLDOWN_SECONDS,
  RECOVERY_EXPIRATION_SECONDS,
} from '@glideco/recovery';

const safeAddress = '0xA1B2c3D4e5F6a7B8c9D0e1F2a3B4c5D6e7F8a9B0';
const recoveryKeyAddress = '0xC3D4e5F6a7B8c9D0e1F2a3B4c5D6e7F8a9B0C1D2'; // Glide KMS (Seat R)

const setup = composeEnableRecoveryModuleCalls({
  // The Safe address — enableModule must be called by the Safe itself
  safe: safeAddress,
  // DelayInitializerInput: configures the Delay module's owner, avatar, target, cooldown
  initializer: {
    owner: recoveryKeyAddress,   // address allowed to queue recovery txs
    avatar: safeAddress,          // the Safe whose balance is acted on
    target: safeAddress,          // where execTransactionFromModule routes (== avatar)
    cooldown: RECOVERY_COOLDOWN_SECONDS,     // 72h default
    expiration: RECOVERY_EXPIRATION_SECONDS, // 7d window to execute after cooldown
  },
  // Optional: masterCopy defaults to Zodiac Delay v1.0.1
  // Optional: saltNonce defaults to 0n (first deployment on this Safe+chain pair)
});

// setup.moduleAddress — deterministic CREATE2 address for the Delay module
// setup.deploy       — { to, value, data } call to deploy via ModuleProxyFactory
// setup.enable       — { to, value, data } call to enableModule on the Safe

// Combine into a Safe multi-send and collect the user's signature:
const safeTx = buildMultiSend([setup.deploy, setup.enable]);

import { composeRecoveryAction } from '@glideco/recovery';

// Recovery key proposes rotating to a new owner (e.g., after key loss):
const composed = composeRecoveryAction({
  safe: '0xA1B2c3D4e5F6a7B8c9D0e1F2a3B4c5D6e7F8a9B0',
  delayModuleAddress: setup.moduleAddress,
  action: {
    kind: 'swap_owner',
    prevOwner: '0x0000000000000000000000000000000000000001', // sentinel — caller reads Safe.getOwners()
    oldOwner:  '0xB2C3d4E5f6A7b8C9D0e1F2a3B4C5d6E7F8a9B0C1',  // lost key
    newOwner:  '0xC3D4e5F6a7B8c9D0e1F2a3B4c5D6e7F8a9B0C1D2',  // replacement key
  },
});

// Persist composed.innerTx to DB (status='pending')
// composed.queueCall  — { to: delayModule, value: '0', data: '0x...' } — recovery key signs + broadcasts
// composed.executeCall — { to: delayModule, value: '0', data: '0x...' } — anyone broadcasts after cooldown
// composed.safe, composed.delayModuleAddress — echo of inputs (lowercased)
// composed.kind    — 'swap_owner'
// composed.summary — human-readable one-liner for audit logs

// After 72h cooldown, broadcast the pre-composed execute call:
// (re-read innerTx from DB to ensure byte-stable replay)
const executeCall = composed.executeCall;

import { readDelayModuleQueueState } from '@glideco/recovery';
import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://mainnet.base.org');

const state = await readDelayModuleQueueState({
  delayModuleAddress: setup.moduleAddress,
  provider,
});
// state = {
//   cooldownSeconds: 259200,   // 72h
//   expirationSeconds: 604800, // 7d window to execute after cooldown
//   queueNonce: 1n,            // next item to queue
//   txNonce: 0n,               // next item to execute (execute < queue = items pending)
// }

import {
  composeSolanaRecoveryAction,
  composeSolanaCancelRecoveryInstruction,
  recomposeSolanaExecuteRecoveryInstruction,
} from '@glideco/recovery';

// Seat R (recovery key) proposes swapping a lost member:
const composed = composeSolanaRecoveryAction({
  multisigPda: 'GrAkKfEpTKQuVHG2Y97Y2FF4i7y7Q5AHLK94KB5hwkhU',
  transactionIndex: BigInt(7),
  currentThreshold: 2,
  creator: '4Nd1mBQtrMJVYVfKf2PX98HegncxXSystemRecoveryKey',  // Seat R base58 pubkey
  recoveryActionId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',   // DB row UUID — embedded in on-chain memo
  action: {
    kind: 'swap_owner',
    oldMember: '4Nd1mBQtrMJVYVfKf2PX98HegncxXLostKeyPubkey1',  // base58 — lost key
    newMember: 'DHmk7x1qGQUos2nsfQ3sJMnFHRWXYReplacementKey1', // base58 — replacement key
  },
});

// composed.proposeInstructions  — [configTxCreate, proposalCreate, proposalApprove] (EncodedInstruction[])
// composed.executeInstruction   — pre-composed configTransactionExecute (EncodedInstruction)
// composed.innerTx              — SolanaInnerTx payload to persist in DB for replay
// composed.multisigPda          — echo of input
// composed.transactionIndex     — decimal string of the u64 index
// composed.kind                 — 'swap_owner'
// composed.summary              — human-readable one-liner for audit logs

// User-initiated veto before cooldown ends:
const cancel = composeSolanaCancelRecoveryInstruction({
  multisigPda: 'GrAkKfEpTKQuVHG2Y97Y2FF4i7y7Q5AHLK94KB5hwkhU',
  transactionIndex: BigInt(7),
  member: 'UserSeatAPubkeyBase58xxxxxxxxxxxxxxxxxxxxxxxxxxxx',  // user's Seat A pubkey
  recoveryActionId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',   // same DB row UUID — for cancel memo
});
// returns a single EncodedInstruction (proposalCancel)

// Execute after cooldown — recompose from the persisted inner_tx:
const exec = recomposeSolanaExecuteRecoveryInstruction({
  innerTx: composed.innerTx,   // SolanaInnerTx from DB — NOT re-derived from scratch
  member: '4Nd1mBQtrMJVYVfKf2PX98HegncxXSystemRecoveryKey', // Seat R — any multisig member works
});
// returns a single EncodedInstruction (configTransactionExecute)

import {
  RECOVERY_ALLOWED_INSTRUCTION_HEX,
  extractInstructionDiscriminatorHex,
} from '@glideco/recovery';

for (const ix of versionedTx.message.compiledInstructions) {
  const disc = extractInstructionDiscriminatorHex(ix.data);
  if (!RECOVERY_ALLOWED_INSTRUCTION_HEX.has(disc)) {
    throw new Error(`recovery tx contains a non-recovery instruction: ${disc}`);
  }
}