author_rotateKeys - Acala RPC Method

Generate a new set of session keys on Acala. This method creates fresh cryptographic keys for all session key types (e.g., BABE, GRANDPA, ImOnline, ParaValidator, AuthorityDiscovery) and stores them in the node's local keystore. The returned concatenated public keys must be registered on-chain via session.setKeys.

Why Acala? Build on Polkadot's DeFi and liquidity hub with aUSD stablecoin and liquid staking (LDOT) with $250M aUSD ecosystem fund, 150%+ LDOT TVL growth, micro gas fees payable in any token, and Coinbase Cloud partnership.

When to Use This Method

author_rotateKeys is critical for DeFi developers, stablecoin builders, and teams requiring cross-chain liquidity:

• Validator Setup — Generate initial session keys when setting up a new validator on decentralized stablecoin (aUSD), liquid DOT staking (LDOT), and cross-chain AMM DEX
• Key Rotation — Periodically rotate keys for operational security best practices
• Recovery — Generate replacement keys after a potential key compromise or node migration
• Validator Upgrades — Produce new keys when moving a validator to new hardware

Code Examples

Common Use Cases

1. Complete Validator Setup Workflow

Full end-to-end validator setup on Acala:

async function setupValidator(api, stashAccount) {
  // Step 1: Generate session keys
  const keys = await api.rpc.author.rotateKeys();
  console.log('Generated session keys:', keys.toHex());

  // Step 2: Register keys on-chain
  const setKeysTx = api.tx.session.setKeys(keys, '0x');
  await new Promise((resolve, reject) => {
    setKeysTx.signAndSend(stashAccount, ({ status, events }) => {
      if (status.isFinalized) {
        const success = events.some(({ event }) =>
          api.events.system.ExtrinsicSuccess.is(event)
        );
        if (success) {
          console.log('Session keys registered successfully');
          resolve();
        } else {
          reject(new Error('setKeys transaction failed'));
        }
      }
    });
  });

  // Step 3: Verify registration
  const nextKeys = await api.query.session.nextKeys(stashAccount.address);
  console.log('Keys registered for next session:', nextKeys.isSome);
}

2. Scheduled Key Rotation

Automate periodic key rotation for security:

async function scheduleKeyRotation(api, validatorAccount, intervalDays = 30) {
  const intervalMs = intervalDays * 24 * 60 * 60 * 1000;

  async function rotateAndRegister() {
    try {
      const newKeys = await api.rpc.author.rotateKeys();
      console.log(`Rotated keys at ${new Date().toISOString()}`);

      const tx = api.tx.session.setKeys(newKeys, '0x');
      await tx.signAndSend(validatorAccount);
      console.log('New keys registered — active next session');
    } catch (error) {
      console.error('Key rotation failed:', error.message);
    }
  }

  // Initial rotation
  await rotateAndRegister();

  // Schedule future rotations
  setInterval(rotateAndRegister, intervalMs);
}

Validator Setup Workflow

1. Generate keys — Call author_rotateKeys on your validator node
2. Register on-chain — Submit session.setKeys(keys, proof) extrinsic from your stash account
3. Wait for session — Keys become active at the start of the next session
4. Verify — Query session.nextKeys to confirm registration

Security Considerations

• Local access only — Only call this method on your own validator node via localhost
• Never expose publicly — This RPC method is marked as unsafe and should not be accessible from the internet
• Keystore security — Session keys are stored in the node's keystore directory on disk
• Rotate regularly — Follow a key rotation schedule to limit exposure from potential compromises
• Backup awareness — New keys replace old ones in the keystore; old keys cannot be recovered

Error Handling

Related Methods

• author_hasSessionKeys — Check if session keys exist in the keystore
• author_submitExtrinsic — Submit the setKeys transaction
• author_pendingExtrinsics — View pending transactions
• session_nextKeys — Query registered session keys on-chain