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 exprimé en unités de base. Pour un jeton à 6 décimales, 1_000_000 signifie 1 jeton.
Le programme rejette les transferts qui dépassent le montant restant disponible pour la période en cours.
Une fois la période suivante commencée, le montant prélevé est réinitialisé.
L'utilisateur signe les transactions de configuration et de révocation. Le délégataire signe les transferts.