Merge pull request #150 from m0-foundation/portal-executor-integration

PROTO-317: Portal executor integration

Author: SC4RECOIN

Cargo.lock

@@ -23,8 +23,12 @@ anchor-lang = { workspace = true, features = ["init-if-needed"] }
 anchor-spl.workspace = true
 spl-token-2022.workspace = true
 wormhole-anchor-sdk = { git = "https://github.com/wormhole-foundation/wormhole-scaffolding", default-features = false, rev = "3be80a9"}
+executor-account-resolver-svm = { version = "0.0.1", git = "https://github.com/wormholelabs-xyz/executor-account-resolver-svm", rev = "a39fe39cece715b3e1d1afef1f6e47740595a562" }
 wormhole-io = "0.1.3"
 bitmaps = "3.2.1"
 cfg-if.workspace = true
 solana-security-txt.workspace = true
 earn = { path = "../earn", features = ["cpi"] }
+
+[dev-dependencies]
+base64 = "0.22.1"

programs/portal/Cargo.toml

@@ -881,6 +881,33 @@
         },
         {
           "name": "ext_program"
+        },
+        {
+          "name": "ext_global",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  103,
+                  108,
+                  111,
+                  98,
+                  97,
+                  108
+                ]
+              }
+            ],
+            "program": {
+              "kind": "account",
+              "path": "ext_program"
+            }
+          }
+        },
+        {
+          "name": "ext_mint",
+          "writable": true
         }
       ],
       "args": []
@@ -1273,11 +1300,35 @@
           {
             "name": "whitelisted_extensions",
             "type": {
-              "vec": "pubkey"
+              "vec": {
+                "defined": {
+                  "name": "WhitelistedExtension"
+                }
+              }
             }
           }
         ]
       }
+    },
+    {
+      "name": "WhitelistedExtension",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "program_id",
+            "type": "pubkey"
+          },
+          {
+            "name": "mint",
+            "type": "pubkey"
+          },
+          {
+            "name": "token_program",
+            "type": "pubkey"
+          }
+        ]
+      }
     }
   ],
   "constants": [

programs/portal/idls/ext_swap.json

@@ -60,7 +60,8 @@ pub struct Config {
     pub release_inbound_remaining_accounts: [RemainingAccount; 2],
     /// destination token addresses
     pub evm_token: [u8; 32],
-    pub evm_wrapped_token: [u8; 32],
+    /// lut for resolve_execute
+    pub resolve_lut: Pubkey,
 }
 
 #[derive(AnchorSerialize, AnchorDeserialize, Clone, InitSpace)]

programs/portal/src/config.rs

@@ -63,6 +63,12 @@ pub enum NTTError {
     ThresholdTooHigh,
     #[msg("InvalidTransceiverProgram")]
     InvalidTransceiverProgram,
+    #[msg("InvalidVAA")]
+    InvalidVAA,
+    #[msg("RESOLVER_RESULT_ACCOUNT needs to be writable")]
+    InvalidReturnAccount,
+    #[msg("Missing payer account")]
+    MissingPayerAccount,
 }
 
 impl From<ScalingError> for NTTError {

programs/portal/src/error.rs

@@ -1,10 +1,14 @@
 use anchor_lang::prelude::*;
 use anchor_spl::{associated_token::AssociatedToken, token_interface};
+use executor_account_resolver_svm::{
+    RESOLVER_RESULT_ACCOUNT_INIT_SIZE, RESOLVER_RESULT_ACCOUNT_SEED,
+};
 
 use crate::{
     bitmap::Bitmap,
     config::{Config, RemainingAccount},
     error::NTTError,
+    instructions::ExecutorAccountResolverResult,
     ntt_messages::{BpfLoaderUpgradeable, ChainId, Mode},
     queue::{outbox::OutboxRateLimit, rate_limit::RateLimitState},
 };
@@ -87,6 +91,7 @@ pub struct InitializeArgs {
     pub chain_id: u16,
     pub limit: u64,
     pub mode: Mode,
+    pub evm_token: [u8; 32],
 }
 
 pub fn initialize(ctx: Context<Initialize>, args: InitializeArgs) -> Result<()> {
@@ -111,8 +116,8 @@ pub fn initialize(ctx: Context<Initialize>, args: InitializeArgs) -> Result<()>
                 true,
             ),
         ],
-        evm_token: [0; 32],
-        evm_wrapped_token: [0; 32],
+        evm_token: args.evm_token,
+        resolve_lut: Pubkey::default(),
     });
 
     ctx.accounts.rate_limit.set_inner(OutboxRateLimit {
@@ -123,25 +128,33 @@ pub fn initialize(ctx: Context<Initialize>, args: InitializeArgs) -> Result<()>
 }
 
 #[derive(Accounts)]
-pub struct SetDestinationAddresses<'info> {
+pub struct InitializeResolverAccounts<'info> {
+    #[account(mut)]
     pub owner: Signer<'info>,
 
     #[account(
         mut,
         has_one = owner,
-        seeds = [Config::SEED_PREFIX],
+    )]
+    pub config: Account<'info, Config>,
+
+    #[account(
+        init_if_needed,
+        payer = owner,
+        space = 8 + RESOLVER_RESULT_ACCOUNT_INIT_SIZE,
+        seeds = [RESOLVER_RESULT_ACCOUNT_SEED],
         bump
     )]
-    pub config: Box<Account<'info, Config>>,
+    pub result_account: Account<'info, ExecutorAccountResolverResult>,
+
+    system_program: Program<'info, System>,
 }
 
-pub fn set_destination_addresses(
-    ctx: Context<SetDestinationAddresses>,
-    evm_token: [u8; 32],
-    evm_wrapped_token: [u8; 32],
+pub fn initialize_resolver_accounts(
+    ctx: Context<InitializeResolverAccounts>,
+    additional_lut: Option<Pubkey>,
 ) -> Result<()> {
-    ctx.accounts.config.evm_token = evm_token;
-    ctx.accounts.config.evm_wrapped_token = evm_wrapped_token;
+    ctx.accounts.config.resolve_lut = additional_lut.unwrap_or_default();
 
     Ok(())
 }

programs/portal/src/instructions/initialize.rs

@@ -6,6 +6,7 @@ pub mod luts;
 pub mod redeem;
 pub mod release_inbound;
 pub mod release_inbound_extension;
+pub mod resolve_execute;
 pub mod transfer;
 pub mod transfer_extension;
 
@@ -16,6 +17,7 @@ pub use luts::*;
 pub use redeem::*;
 pub use release_inbound::*;
 pub use release_inbound_extension::*;
+pub use resolve_execute::*;
 pub use transfer::*;
 pub use transfer_extension::*;
 

programs/portal/src/instructions/mod.rs

@@ -13,7 +13,7 @@ use crate::{
     error::NTTError,
     instructions::BridgeEvent,
     ntt_messages::Mode,
-    queue::inbox::{InboxItem, ReleaseStatus, TokenTransfer},
+    queue::inbox::{InboxItem, ReleaseStatus},
 };
 
 #[derive(Accounts)]
@@ -58,6 +58,7 @@ pub struct ReleaseInboundMint<'info> {
     pub earn_program: Program<'info, Earn>,
 
     #[account(
+        mut,
         seeds = [GLOBAL_SEED],
         seeds::program = earn::ID,
         bump = m_global.bump,
@@ -73,25 +74,16 @@ pub struct ReleaseInboundArgs {
 pub fn release_inbound_mint<'info>(
     ctx: Context<'_, '_, '_, 'info, ReleaseInboundMint<'info>>,
     args: ReleaseInboundArgs,
-) -> Result<()> {
-    release_inbound(ctx, args, false)
-}
-
-pub fn release_inbound<'info>(
-    ctx: Context<'_, '_, '_, 'info, ReleaseInboundMint<'info>>,
-    args: ReleaseInboundArgs,
-    release_extension: bool,
 ) -> Result<()> {
     let inbox_item = &mut ctx.accounts.inbox_item;
 
     // Validate token account depending on call context
     validate_recipient_token_account(
         &ctx.accounts.recipient.key(),
-        &inbox_item.transfer,
+        &inbox_item,
         &ctx.accounts.token_authority.key(),
         &ctx.accounts.mint.key(),
         &ctx.accounts.token_program.key(),
-        release_extension,
     )?;
 
     if !inbox_item.try_release()? {
@@ -186,40 +178,53 @@ pub fn release_inbound<'info>(
 
 fn validate_recipient_token_account(
     recipient: &Pubkey,
-    transfer: &TokenTransfer,
+    inbox_item: &InboxItem,
     token_authority: &Pubkey,
-    mint: &Pubkey,
+    m_mint: &Pubkey,
     token_program: &Pubkey,
-    release_extension: bool,
 ) -> Result<()> {
+    let expected = get_inbox_recipient_token_account(
+        &inbox_item.transfer.recipient,
+        &inbox_item.destination_mint,
+        inbox_item.transfer.amount,
+        token_authority,
+        m_mint,
+        token_program,
+    );
+
+    if expected.is_some() && !expected.unwrap().eq(recipient) {
+        return err!(NTTError::InvalidRecipientAddress);
+    }
+
+    Ok(())
+}
+
+pub fn get_inbox_recipient_token_account(
+    recipient: &Pubkey,
+    destination_mint: &Pubkey,
+    amount: u64,
+    token_authority: &Pubkey,
+    m_mint: &Pubkey,
+    token_program: &Pubkey,
+) -> Option<Pubkey> {
     // Only bridging data
-    if transfer.amount == 0 {
-        return Ok(());
+    if amount == 0 {
+        return None;
     }
 
     // Bridging to extension, require intermediate portal token account
-    if release_extension {
-        if !recipient.eq(&get_associated_token_address_with_program_id(
+    if !destination_mint.eq(m_mint) {
+        return Some(get_associated_token_address_with_program_id(
             token_authority,
-            mint,
+            m_mint,
             token_program,
-        )) {
-            msg!("expected recipient to be token authority");
-            return err!(NTTError::InvalidRecipientAddress);
-        }
-
-        return Ok(());
+        ));
     }
 
     // Bridging $M, require user token account
-    if !recipient.eq(&get_associated_token_address_with_program_id(
-        &transfer.recipient,
-        mint,
+    Some(get_associated_token_address_with_program_id(
+        &recipient,
+        m_mint,
         token_program,
-    )) {
-        msg!("expected recipient to match inbox item");
-        return err!(NTTError::InvalidRecipientAddress);
-    }
-
-    Ok(())
+    ))
 }

programs/portal/src/instructions/release_inbound.rs

@@ -4,8 +4,8 @@ use earn::state::GLOBAL_SEED;
 use ext_swap::accounts::SwapGlobal;
 use ext_swap::program::ExtSwap;
 
-use crate::instructions::ext_swap;
-use crate::instructions::{release_inbound, ReleaseInboundArgs, ReleaseInboundMint};
+use crate::instructions::{ext_swap, release_inbound_mint};
+use crate::instructions::{ReleaseInboundArgs, ReleaseInboundMint};
 use crate::ReleaseInboundMintBumps;
 use crate::__client_accounts_release_inbound_mint;
 use crate::__cpi_client_accounts_release_inbound_mint;
@@ -94,7 +94,7 @@ pub fn release_inbound_mint_extension<'info>(
     let token_auth_bump = ctx.bumps.common.token_authority;
 
     // Release bridged $M
-    release_inbound(
+    release_inbound_mint(
         Context::new(
             ctx.program_id,
             &mut ctx.accounts.common,
@@ -108,7 +108,6 @@ pub fn release_inbound_mint_extension<'info>(
             // always revert on delay or wrap will fail
             revert_when_not_ready: true,
         },
-        true,
     )?;
 
     ctx.accounts.common.recipient.reload()?;