Wiederkehrende Delegation

Eine wiederkehrende Delegation ermöglicht es einem Benutzer, einer anderen Wallet oder einem Dienst die Genehmigung zu erteilen, bis zu einem Limit abzuheben, das sich in jeder Periode zurücksetzt.

Diese Anleitung hält die beweglichen Teile sichtbar. Sie leiten zuerst die Konten ab, initialisieren bei Bedarf die Subscription Authority, erstellen die wiederkehrende Delegation und verwenden dann diese Delegations-PDA für Überweisungen.

Installation

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

Delegation erstellen

Die Einrichtung besteht aus vier Teilen:

Erstellen Sie einen Client mit dem Benutzer-Signer und dem Subscriptions-Plugin.
Leiten Sie das Token-Konto des Benutzers, die Subscription Authority PDA und die wiederkehrende Delegations-PDA ab.
Initialisieren Sie die Subscription Authority, falls diese noch nicht existiert.
Erstellen Sie die wiederkehrende Delegation mit dem Periodenbetrag, der Periodenlänge, der Startzeit und dem Ablaufdatum.

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();

Überweisung von der Delegation

Der Delegierte signiert jede Überweisung. Das Programm überprüft die aktuelle Periode und lehnt Überweisungen ab, die das verbleibende Limit der Periode überschreiten würden.

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();

Delegation widerrufen

Der Delegierende kann die wiederkehrende Delegation jederzeit widerrufen. Durch den Widerruf wird das Delegations-PDA geschlossen und dessen rent an den Signer zurückgegeben.

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

Hinweise

amountPerPeriod ist in Basiseinheiten angegeben. Bei einem Token mit 6 Dezimalstellen bedeutet 1_000_000 1 Token.
Das Programm lehnt Transfers ab, die das verbleibende Limit der aktuellen Periode überschreiten.
Sobald die nächste Periode beginnt, wird der abgerufene Betrag zurückgesetzt.
expiryTs ist eine harte Grenze: Sobald sie überschritten wird, schlagen Transfers fehl und der Sponsor kann rent zurückfordern. Es gibt keine Nachfrist für Ausgaben.
Setze startTs auf 0, um die Delegation zu starten, sobald die Transaktion auf der Chain landet, anstatt zu einem festen Zeitpunkt. Dies erweitert das Zeitfenster, um den Nutzer zum Signieren und Onboarding zu bewegen. In diesem Fall muss expiryTs ungleich null sein – eine Delegation mit Start beim Landing kann nicht gleichzeitig auf unbegrenzte Gültigkeit gesetzt werden.
Der Nutzer signiert Setup- und Widerrufstransaktionen. Der Delegierte signiert Transfers.