Délégation fixe

Une délégation fixe permet à un utilisateur d'autoriser un autre portefeuille ou service à retirer jusqu'à un montant de jetons fixe. Chaque transfert réussi réduit l'allocation restante. Utilisez expiryTs = 0 pour aucune expiration.

Ce guide maintient le flux visible. Chaque extrait utilise directement les fonctions du SDK afin que vous puissiez voir quel compte est dérivé, quelle instruction est envoyée et quel signataire paie ou autorise chaque étape.

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 token account de l'utilisateur et le PDA de l'autorité d'abonnement.
Initialiser l'autorité d'abonnement si elle n'existe pas encore.
Créer la délégation fixe et dériver son PDA pour les transferts ultérieurs.

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,
  findFixedDelegationPda,
  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 nonce = 0n;
const amount = 1_000_000n;
const expiryTs = BigInt(Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30);

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

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

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
  .createFixedDelegation({
    tokenMint,
    delegatee,
    nonce,
    amount,
    expiryTs,
  })
  .sendTransaction();

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

Transférer depuis la délégation

Le délégataire signe le transfert. Le SDK nécessite le même PDA de délégation, le token account de l'utilisateur et le token account du destinataire.

const receiverAta = address('RECEIVER_TOKEN_ACCOUNT_ADDRESS_HERE');

await client.subscriptions.instructions
  .transferFixed({
    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égant peut révoquer la délégation à tout moment. La révocation ferme le PDA de délégation et retourne son rent au signataire.

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

Remarques

Le token account de l'utilisateur doit exister avant l'initialisation.
Les montants sont exprimés en unités de base. Pour un jeton à 6 décimales, 1_000_000 signifie 1 jeton.
Exécutez initSubscriptionAuthority uniquement lorsque le compte Subscription Authority n'existe pas déjà.
L'utilisateur signe les transactions de configuration et de révocation. Le délégataire signe les transferts.