Libérer des fonds

Appelée par un opérateur provisionné pour libérer des tokens en escrow vers le portefeuille Mainnet d'un utilisateur, sous réserve d'une preuve d'exclusion de l'arbre de Merkle creux (SMT) valide pour le nonce de retrait.

Le programme d'escrow est en cours de migration depuis cette conception d'arbre de Merkle creux vers un bitmap de nonces on-chain (suivi en amont). Cette page est exacte par rapport au programme d'escrow actuel et sera mise à jour une fois ce changement déployé.

Comptes

Compte	Modifiable	Signataire	Description
`payer`	✓	✓	Payeur des frais
`operator`		✓	Signataire opérateur
`instance`	✓		PDA de l'instance d'escrow (racine mise à jour on-chain)
`operator_pda`			PDA opérateur prouvant que le signataire est provisionné
`mint`			Mint de token SPL
`allowed_mint`			PDA AllowedMint - valide que le mint est autorisé sur cette instance
`user_ata`	✓		associated token account du destinataire (destination)
`instance_ata`	✓		associated token account de l'escrow (source)
`token_program`			SPL Token Program
`associated_token_program`			Associated Token Program
`event_authority`			PDA d'autorité d'événement pour le CPI `EmitEvent`
`private_channel_escrow_program`			Programme d'escrow (auto-référence pour CPI)

Paramètres

Paramètre	Type	Description
`amount`	`u64`	Montant de tokens à libérer
`user`	`Pubkey`	Portefeuille destinataire sur le Mainnet
`new_withdrawal_root`	`[u8; 32]`	Racine SMT mise à jour après inclusion du nonce de ce retrait
`transaction_nonce`	`u64`	Nonce unique identifiant la feuille de ce retrait dans le SMT
`sibling_proofs`	`[u8; 512]`	16 hachages frères (32 octets chacun) pour la preuve d'exclusion SMT

Valeur de retour

Retourne un TransactionBuilder pouvant être utilisé pour construire et envoyer la transaction.

Exemple

import { getReleaseFundsInstruction } from "../private-channel-escrow-program/clients/typescript/src/generated";

const releaseIx = getReleaseFundsInstruction({
  payer: operatorPayerSigner,
  operator: operatorSigner,
  instance: instancePda,
  operatorPda: operatorPdaAddress,
  mint: mintAddress,
  allowedMint: allowedMintPda,
  userAta: userAtaAddress,
  instanceAta: instanceAtaAddress,
  tokenProgram: TOKEN_PROGRAM_ID,
  associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
  eventAuthority: eventAuthorityPda,
  privateChannelEscrowProgram: ESCROW_PROGRAM_ID,
  amount: 1_000_000n,
  user: recipientPublicKey,
  newWithdrawalRoot: newSmtRoot, // [u8; 32]
  transactionNonce: withdrawalNonce, // u64
  siblingProofs: proofBytes // Uint8Array(512)
});

Notes importantes

L'appelant doit être un opérateur provisionné : operator_pda doit exister (créé par AddOperator) ; un PDA invalide lève l'erreur InvalidOperatorPda
sibling_proofs fait exactement 512 octets (16 × 32 octets de hachages, correspondant à la hauteur d'arbre SMT de 16)
new_withdrawal_root est la racine SMT mise à jour après inclusion du nonce de ce retrait. Calculez-la hors-chaîne avant d'appeler
transaction_nonce doit être valide pour Instance.current_tree_index ; un nonce invalide lève l'erreur InvalidTransactionNonceForCurrentTreeIndex
Le programme exécute d'abord verify_smt_exclusion_proof, prouvant que le nonce n'existe PAS encore par rapport à la racine actuelle, puis exécute séparément verify_smt_inclusion_proof prouvant que le nonce EXISTE bien dans le new_withdrawal_root fourni par l'appelant. L'échec de l'une ou l'autre vérification lève l'erreur InvalidSmtProof
Ce n'est qu'après la réussite des deux vérifications que Instance.withdrawal_transactions_root est mis à jour de manière atomique ; le nonce ne peut pas être réutilisé
Émet un événement via le CPI EmitEvent