Délégation récurrente

Une délégation récurrente permet à un utilisateur d'autoriser un autre portefeuille ou service à retirer jusqu'à une limite qui se réinitialise à chaque période.

Ce guide maintient les éléments mobiles visibles. Vous dérivez d'abord les comptes, initialisez l'Autorité d'abonnement si nécessaire, créez la délégation récurrente, puis utilisez ce PDA de délégation pour les transferts.

Installation

pnpm add @solana/subscriptions @solana/kit @solana/kit-plugin-rpc @solana/kit-plugin-signer @solana-program/token

Créer la délégation

La configuration comporte quatre parties :

Créer un client avec le signataire utilisateur et le plugin d'abonnements.
Dériver le compte de jetons de l'utilisateur, le PDA de l'Autorité d'abonnement et le PDA de délégation récurrente.
Initialiser l'Autorité d'abonnement si elle n'existe pas encore.
Créer la délégation récurrente avec le montant de période, la durée de période, l'heure de début et l'expiration.

import { address, createClient } from '@solana/kit';
import { solanaLocalRpc } from '@solana/kit-plugin-rpc';
import { signer } from '@solana/kit-plugin-signer';
import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
import {
  fetchMaybeSubscriptionAuthority,
  findRecurringDelegationPda,
  findSubscriptionAuthorityPda,
  subscriptionsProgram,
} from '@solana/subscriptions';

const client = createClient()
  .use(signer(userSigner))
  .use(solanaLocalRpc({ rpcUrl: 'http://127.0.0.1:8899' }))
  .use(subscriptionsProgram());

const tokenMint = address('TOKEN_MINT_ADDRESS_HERE');
const delegatee = address('DELEGATEE_WALLET_ADDRESS_HERE');
const now = BigInt(Math.floor(Date.now() / 1000));
const nonce = 0n;
const amountPerPeriod = 1_000_000n;
const periodLengthS = 86_400n;
const startTs = now;
const expiryTs = now + periodLengthS * 30n;

const [userAta] = await findAssociatedTokenPda({
  mint: tokenMint,
  owner: userSigner.address,
  tokenProgram: TOKEN_PROGRAM_ADDRESS,
});

const [subscriptionAuthorityPda] = await findSubscriptionAuthorityPda({
  user: userSigner.address,
  tokenMint,
});

const [delegationPda] = await findRecurringDelegationPda({
  subscriptionAuthority: subscriptionAuthorityPda,
  delegator: userSigner.address,
  delegatee,
  nonce,
});

const subscriptionAuthority = await fetchMaybeSubscriptionAuthority(
  client.rpc,
  subscriptionAuthorityPda,
);

if (!subscriptionAuthority.exists) {
  await client.subscriptions.instructions
    .initSubscriptionAuthority({
      tokenMint,
      tokenProgram: TOKEN_PROGRAM_ADDRESS,
      userAta,
    })
    .sendTransaction();
}

await client.subscriptions.instructions
  .createRecurringDelegation({
    tokenMint,
    delegatee,
    nonce,
    amountPerPeriod,
    periodLengthS,
    startTs,
    expiryTs,
  })
  .sendTransaction();

Transférer depuis la délégation

Le délégataire signe chaque transfert. Le programme vérifie la période actuelle et rejette les transferts qui dépasseraient le montant restant autorisé pour la période.

const receiverAta = address('RECEIVER_TOKEN_ACCOUNT_ADDRESS_HERE');

await client.subscriptions.instructions
  .transferRecurring({
    delegatee: delegateeSigner,
    delegator: userSigner.address,
    delegatorAta: userAta,
    tokenMint,
    delegationPda,
    amount: 100_000n,
    receiverAta,
    tokenProgram: TOKEN_PROGRAM_ADDRESS,
  })
  .sendTransaction();

Révoquer la délégation

Le délégataire peut révoquer la délégation récurrente à tout moment. La révocation ferme le PDA de délégation et retourne son loyer au signataire.

await client.subscriptions.instructions
  .revokeDelegation({
    authority: userSigner,
    delegationAccount: delegationPda,
  })
  .sendTransaction();

Remarques

amountPerPeriod est en unités de base. Pour un token à 6 décimales, 1_000_000 signifie 1 token.
Le programme rejette les transferts qui dépassent l'allocation restante de la période en cours.
Au début de la période suivante, le montant prélevé est réinitialisé.
expiryTs est une limite stricte : une fois dépassée, les transferts échouent et le sponsor peut récupérer le rent. Il n'existe pas de délai de grâce basé sur le temps de dépense.
Définissez startTs sur 0 pour démarrer la délégation au moment où la transaction est enregistrée sur la chaîne plutôt qu'à une heure fixe. Cela élargit la fenêtre pour amener l'utilisateur à signer et à s'inscrire. Dans ce cas, expiryTs doit être non nul — une délégation à démarrage à l'atterrissage ne peut pas également être configurée pour ne jamais expirer.
L'utilisateur signe les transactions de configuration et de révocation. Le délégué signe les transferts.