fix:ran pnpm fix

Author: adpthegreat

tokens/escrow/poseidon/escrow_program/Anchor.toml

@@ -5,7 +5,7 @@ resolution = true
 skip-lint = false
 
 [programs.localnet]
-escrow_program = "8b7Pshe6L28ee9oCTjGHCYTugFCQjKSBGfbaXZt9f3EF"
+escrow_program = "5hP1158bStJmsUneTSbR3b7ENHDUjYiC8hwncye7WYVV"
 
 [registry]
 url = "https://api.apr.dev"

tokens/escrow/poseidon/escrow_program/migrations/deploy.ts

@@ -2,9 +2,9 @@
 // single deploy script that's invoked from the CLI, injecting a provider
 // configured from the workspace's Anchor.toml.
 
-const anchor = require("@coral-xyz/anchor");
+const anchor = require('@coral-xyz/anchor');
 
-module.exports = async function (provider) {
+module.exports = async (provider) => {
   // Configure client to use the provider.
   anchor.setProvider(provider);
 

tokens/escrow/poseidon/escrow_program/programs/escrow_program/src/lib.rs

@@ -1,54 +1,70 @@
 use anchor_lang::prelude::*;
 use anchor_spl::{
     token::{
-        Mint, TokenAccount, Token, transfer as transfer_spl, Transfer as TransferSPL,
+        transfer as transfer_spl, TokenAccount, Mint, Transfer as TransferSPL, Token,
     },
     associated_token::AssociatedToken,
 };
-declare_id!("8b7Pshe6L28ee9oCTjGHCYTugFCQjKSBGfbaXZt9f3EF");
+declare_id!("5hP1158bStJmsUneTSbR3b7ENHDUjYiC8hwncye7WYVV");
 #[program]
 pub mod escrow_program {
     use super::*;
-    pub fn make_offer(
-        ctx: Context<MakeOfferContext>,
-        token_a_offered_amount: u64,
-        token_b_wanted_amount: u64,
-        id: u64,
+    pub fn make(
+        ctx: Context<MakeContext>,
+        deposit_amount: u64,
+        offer_amount: u64,
+        seed: u64,
     ) -> Result<()> {
         ctx.accounts.escrow.auth_bump = ctx.bumps.auth;
         ctx.accounts.escrow.vault_bump = ctx.bumps.vault;
         ctx.accounts.escrow.escrow_bump = ctx.bumps.escrow;
         ctx.accounts.escrow.maker = ctx.accounts.maker.key();
-        ctx.accounts.escrow.token_mint_a = ctx.accounts.token_mint_a.key();
-        ctx.accounts.escrow.token_mint_b = ctx.accounts.token_mint_b.key();
-        ctx.accounts.escrow.token_b_wanted_amount = token_b_wanted_amount;
-        ctx.accounts.escrow.id = id;
+        ctx.accounts.escrow.amount = offer_amount;
+        ctx.accounts.escrow.seed = seed;
+        ctx.accounts.escrow.maker_mint = ctx.accounts.maker_mint.key();
+        ctx.accounts.escrow.taker_mint = ctx.accounts.taker_mint.key();
         let cpi_accounts = TransferSPL {
-            from: ctx.accounts.maker_token_account_a.to_account_info(),
+            from: ctx.accounts.maker_ata.to_account_info(),
             to: ctx.accounts.vault.to_account_info(),
             authority: ctx.accounts.maker.to_account_info(),
         };
         let cpi_ctx = CpiContext::new(
             ctx.accounts.token_program.to_account_info(),
             cpi_accounts,
         );
-        transfer_spl(cpi_ctx, token_a_offered_amount)?;
+        transfer_spl(cpi_ctx, deposit_amount)?;
         Ok(())
     }
-    pub fn take_offer(ctx: Context<TakeOfferContext>) -> Result<()> {
+    pub fn refund(ctx: Context<RefundContext>) -> Result<()> {
         let cpi_accounts = TransferSPL {
-            from: ctx.accounts.taker_token_account_a.to_account_info(),
-            to: ctx.accounts.maker_token_account_a.to_account_info(),
+            from: ctx.accounts.vault.to_account_info(),
+            to: ctx.accounts.maker_ata.to_account_info(),
+            authority: ctx.accounts.auth.to_account_info(),
+        };
+        let signer_seeds = &[&b"auth"[..], &[ctx.accounts.escrow.auth_bump]];
+        let binding = [&signer_seeds[..]];
+        let cpi_ctx = CpiContext::new_with_signer(
+            ctx.accounts.token_program.to_account_info(),
+            cpi_accounts,
+            &binding,
+        );
+        transfer_spl(cpi_ctx, ctx.accounts.escrow.amount)?;
+        Ok(())
+    }
+    pub fn take(ctx: Context<TakeContext>) -> Result<()> {
+        let cpi_accounts = TransferSPL {
+            from: ctx.accounts.taker_ata.to_account_info(),
+            to: ctx.accounts.maker_ata.to_account_info(),
             authority: ctx.accounts.taker.to_account_info(),
         };
         let cpi_ctx = CpiContext::new(
             ctx.accounts.token_program.to_account_info(),
             cpi_accounts,
         );
-        transfer_spl(cpi_ctx, ctx.accounts.escrow.token_b_wanted_amount)?;
+        transfer_spl(cpi_ctx, ctx.accounts.escrow.amount)?;
         let cpi_accounts = TransferSPL {
             from: ctx.accounts.vault.to_account_info(),
-            to: ctx.accounts.taker_token_account_b.to_account_info(),
+            to: ctx.accounts.taker_receive_ata.to_account_info(),
             authority: ctx.accounts.auth.to_account_info(),
         };
         let signer_seeds = &[&b"auth"[..], &[ctx.accounts.escrow.auth_bump]];
@@ -58,118 +74,156 @@ pub mod escrow_program {
             cpi_accounts,
             &binding,
         );
-        transfer_spl(cpi_ctx, ctx.accounts.escrow.token_b_wanted_amount)?;
+        transfer_spl(cpi_ctx, ctx.accounts.escrow.amount)?;
         Ok(())
     }
 }
 #[derive(Accounts)]
-#[instruction(id:u64)]
-pub struct MakeOfferContext<'info> {
+#[instruction(seed:u64)]
+pub struct MakeContext<'info> {
+    #[account(seeds = [b"auth"], bump)]
+    /// CHECK: This acc is safe
+    pub auth: UncheckedAccount<'info>,
+    #[account()]
+    pub taker_mint: Account<'info, Mint>,
     #[account(
         init,
         payer = maker,
         space = 123,
         seeds = [b"escrow",
         maker.key().as_ref(),
-        id.to_le_bytes().as_ref()],
+        seed.to_le_bytes().as_ref()],
         bump,
     )]
-    pub escrow: Account<'info, Escrow>,
-    #[account(
-        mut,
-        associated_token::mint = token_mint_a,
-        associated_token::authority = maker,
-    )]
-    pub maker_token_account_a: Account<'info, TokenAccount>,
-    #[account(mut)]
-    pub maker: Signer<'info>,
+    pub escrow: Account<'info, EscrowState>,
     #[account()]
-    pub token_mint_a: Account<'info, Mint>,
-    #[account()]
-    pub token_mint_b: Account<'info, Mint>,
+    pub maker_mint: Account<'info, Mint>,
     #[account(
         init,
         payer = maker,
         seeds = [b"vault",
         escrow.key().as_ref()],
-        token::mint = token_mint_a,
+        token::mint = maker_mint,
         token::authority = auth,
         bump,
     )]
     pub vault: Account<'info, TokenAccount>,
-    #[account(seeds = [b"auth"], bump)]
-    /// CHECK: This acc is safe
-    pub auth: UncheckedAccount<'info>,
+    #[account(
+        mut,
+        associated_token::mint = maker_mint,
+        associated_token::authority = maker,
+    )]
+    pub maker_ata: Account<'info, TokenAccount>,
+    #[account(mut)]
+    pub maker: Signer<'info>,
     pub associated_token_program: Program<'info, AssociatedToken>,
     pub token_program: Program<'info, Token>,
     pub system_program: Program<'info, System>,
 }
 #[derive(Accounts)]
-pub struct TakeOfferContext<'info> {
-    #[account(mut)]
-    pub maker: SystemAccount<'info>,
-    #[account(mut)]
-    pub taker: Signer<'info>,
+pub struct RefundContext<'info> {
     #[account(
         mut,
         seeds = [b"vault",
         escrow.key().as_ref()],
-        token::mint = token_mint_a,
+        token::mint = maker_mint,
         token::authority = auth,
         bump,
     )]
     pub vault: Account<'info, TokenAccount>,
+    #[account(
+        mut,
+        seeds = [b"escrow",
+        maker.key().as_ref(),
+        escrow.seed.to_le_bytes().as_ref()],
+        has_one = maker,
+        bump,
+        close = maker,
+    )]
+    pub escrow: Account<'info, EscrowState>,
     #[account()]
-    pub token_mint_b: Account<'info, Mint>,
+    pub maker_mint: Account<'info, Mint>,
+    #[account(mut)]
+    pub maker: Signer<'info>,
+    #[account(
+        mut,
+        associated_token::mint = maker_mint,
+        associated_token::authority = maker,
+    )]
+    pub maker_ata: Account<'info, TokenAccount>,
+    #[account(seeds = [b"auth"], bump)]
+    /// CHECK: This acc is safe
+    pub auth: UncheckedAccount<'info>,
+    pub associated_token_program: Program<'info, AssociatedToken>,
+    pub token_program: Program<'info, Token>,
+    pub system_program: Program<'info, System>,
+}
+#[derive(Accounts)]
+pub struct TakeContext<'info> {
     #[account(seeds = [b"auth"], bump)]
     /// CHECK: This acc is safe
     pub auth: UncheckedAccount<'info>,
+    #[account(mut)]
+    pub taker: Signer<'info>,
+    #[account()]
+    pub taker_mint: Account<'info, Mint>,
+    #[account(mut)]
+    pub maker: SystemAccount<'info>,
     #[account(
         mut,
         seeds = [b"escrow",
         maker.key().as_ref(),
-        escrow.id.to_le_bytes().as_ref()],
+        escrow.seed.to_le_bytes().as_ref()],
         has_one = maker,
-        has_one = token_mint_a,
-        has_one = token_mint_b,
+        has_one = maker_mint,
+        has_one = taker_mint,
         bump,
         close = maker,
     )]
-    pub escrow: Account<'info, Escrow>,
+    pub escrow: Account<'info, EscrowState>,
     #[account(
         init_if_needed,
         payer = taker,
-        associated_token::mint = token_mint_a,
+        associated_token::mint = maker_mint,
         associated_token::authority = taker,
     )]
-    pub taker_token_account_a: Account<'info, TokenAccount>,
-    #[account()]
-    pub token_mint_a: Account<'info, Mint>,
+    pub taker_receive_ata: Account<'info, TokenAccount>,
     #[account(
         mut,
-        associated_token::mint = token_mint_a,
+        associated_token::mint = maker_mint,
         associated_token::authority = maker,
     )]
-    pub maker_token_account_a: Account<'info, TokenAccount>,
+    pub maker_ata: Account<'info, TokenAccount>,
     #[account(
         init_if_needed,
         payer = taker,
-        associated_token::mint = token_mint_a,
+        associated_token::mint = maker_mint,
         associated_token::authority = taker,
     )]
-    pub taker_token_account_b: Account<'info, TokenAccount>,
+    pub taker_ata: Account<'info, TokenAccount>,
+    #[account()]
+    pub maker_mint: Account<'info, Mint>,
+    #[account(
+        mut,
+        seeds = [b"vault",
+        escrow.key().as_ref()],
+        token::mint = maker_mint,
+        token::authority = auth,
+        bump,
+    )]
+    pub vault: Account<'info, TokenAccount>,
     pub associated_token_program: Program<'info, AssociatedToken>,
-    pub token_program: Program<'info, Token>, 
+    pub token_program: Program<'info, Token>,
     pub system_program: Program<'info, System>,
 }
 #[account]
-pub struct Escrow {
+pub struct EscrowState {
     pub maker: Pubkey,
-    pub token_mint_a: Pubkey,
-    pub token_mint_b: Pubkey,
-    pub token_b_wanted_amount: u64,
-    pub escrow_bump: u8,
-    pub id: u64,
+    pub maker_mint: Pubkey,
+    pub taker_mint: Pubkey,
+    pub amount: u64,
+    pub seed: u64,
     pub auth_bump: u8,
+    pub escrow_bump: u8,
     pub vault_bump: u8,
 }