all tests passing, using latest methods from steel 2.1

robertohuertasm · robertohuertasm · commit 9a90cc6d7fbf · 2024-11-23T12:29:33.000+01:00
diff --git a/basics/transfer-sol/steel/Cargo.toml b/basics/transfer-sol/steel/Cargo.toml
@@ -17,6 +17,5 @@ transfer-sol-api = { path = "./api", version = "0.1.0" }
 bytemuck = "1.14"
 num_enum = "0.7"
 solana-program = "1.18"
-# steel = { version = "1.3", features = ["spl"] }
 steel = "2.1"
 thiserror = "1.0"
diff --git a/basics/transfer-sol/steel/program/src/with_cpi.rs b/basics/transfer-sol/steel/program/src/with_cpi.rs
@@ -1,5 +1,4 @@
 use solana_program::msg;
-use solana_program::{program::invoke, system_instruction};
 use steel::*;
 use transfer_sol_api::prelude::*;
 
@@ -19,16 +18,7 @@ pub fn process_with_cpi(accounts: &[AccountInfo<'_>], data: &[u8]) -> ProgramRes
     receiver_info.is_writable()?;
     system_program.is_program(&system_program::ID)?;
 
-    invoke(
-        &system_instruction::transfer(&signer_info.key, &receiver_info.key, amount),
-        &[
-            signer_info.clone(),
-            receiver_info.clone(),
-            system_program.clone(),
-        ],
-    )?;
-
-    // collect?
+    receiver_info.collect(amount, signer_info)?;
 
     Ok(())
 }
diff --git a/basics/transfer-sol/steel/program/src/with_program.rs b/basics/transfer-sol/steel/program/src/with_program.rs
@@ -17,13 +17,7 @@ pub fn proces_with_program(accounts: &[AccountInfo<'_>], data: &[u8]) -> Program
     payer_info.is_writable()?;
     receiver_info.is_writable()?;
 
-    **payer_info.try_borrow_mut_lamports()? -= amount;
-    **receiver_info.try_borrow_mut_lamports()? += amount;
-
-    // signer_info.send(amount, receiver_info);
-
-    //     **payer.try_borrow_mut_lamports()? -= amount;
-    //     **recipient.try_borrow_mut_lamports()? += amount;
+    payer_info.send(amount, receiver_info);
 
     Ok(())
 }
diff --git a/basics/transfer-sol/steel/program/tests/test.rs b/basics/transfer-sol/steel/program/tests/test.rs
@@ -1,13 +1,9 @@
-use std::vec;
-
 use solana_program::hash::Hash;
 
 use solana_program_test::{processor, BanksClient, ProgramTest};
 use solana_sdk::{
-    config::program, lamports, native_token::LAMPORTS_PER_SOL, signature::Keypair, signer::Signer,
-    transaction::Transaction,
+    native_token::LAMPORTS_PER_SOL, signature::Keypair, signer::Signer, transaction::Transaction,
 };
-use steel::*;
 use transfer_sol_api::prelude::*;
 
 async fn setup() -> (BanksClient, Keypair, Hash) {
@@ -21,28 +17,65 @@ async fn setup() -> (BanksClient, Keypair, Hash) {
     program_test.start().await
 }
 
-//     let system_program_id = &system_program::ID;
-//     let key = Rc::new(*system_program_id);
-//     let lamports = Rc::new(RefCell::new(0));
-//     let data = Rc::new(RefCell::new(vec![]));
-//     let owner = system_program_id;
-//     let is_signer = false;
-//     let is_writable = false;
-
-//     AccountInfo {
-//         key: &*key,
-//         is_signer,
-//         is_writable,
-//         lamports,
-//         data,
-//         owner,
-//         executable: true,
-//         rent_epoch: 0,
-//     }
-// }
+#[tokio::test]
+async fn transfer_with_program_works() {
+    // Setup test
+    let (mut banks, payer, blockhash) = setup().await;
+
+    // 1 SOL
+    let amount = 1 * LAMPORTS_PER_SOL;
+
+    // Generate a couple of keypairs to create accounts owned by our program
+    let acc_1 = Keypair::new();
+    let acc_2 = Keypair::new();
+
+    // Create the program accounts
+    let create_account_instruction = |pubkey| {
+        solana_program::system_instruction::create_account(
+            &payer.pubkey(),
+            pubkey,
+            amount,
+            0,
+            &transfer_sol_api::ID,
+        )
+    };
+
+    let tx_create_accounts = Transaction::new_signed_with_payer(
+        &[
+            create_account_instruction(&acc_1.pubkey()),
+            create_account_instruction(&acc_2.pubkey()),
+        ],
+        Some(&payer.pubkey()),
+        &[&payer, &acc_1, &acc_2],
+        blockhash,
+    );
+
+    let res = banks.process_transaction(tx_create_accounts).await;
+    assert!(res.is_ok());
+
+    // Let's transfer some lamports from acc_1 to acc_2
+    let latest_blockhash = banks.get_latest_blockhash().await.unwrap();
+
+    let ix = with_program(acc_1.pubkey(), acc_2.pubkey(), amount);
+    let tx = Transaction::new_signed_with_payer(
+        &[ix],
+        Some(&payer.pubkey()),
+        &[&payer],
+        latest_blockhash,
+    );
+
+    let res = banks.process_transaction(tx).await;
+    assert!(res.is_ok());
+
+    // Now, let's check the balances
+    let acc_1_balance = banks.get_balance(acc_1.pubkey()).await.unwrap();
+    assert_eq!(acc_1_balance, 0);
+    let acc_2_balance = banks.get_balance(acc_2.pubkey()).await.unwrap();
+    assert_eq!(acc_2_balance, 2 * amount);
+}
 
 #[tokio::test]
-async fn run_test() {
+async fn transfer_with_cpi_works() {
     // Setup test
     let (mut banks, payer, blockhash) = setup().await;
 
@@ -58,33 +91,6 @@ async fn run_test() {
     let res = banks.process_transaction(tx).await;
     assert!(res.is_ok());
 
-    // // Verify counter was initialized.
-    // let counter_address = counter_pda().0;
-    // let counter_account = banks.get_account(counter_address).await.unwrap().unwrap();
-    // let counter = Counter::try_from_bytes(&counter_account.data).unwrap();
-    // assert_eq!(counter_account.owner, transfer_sol_api::ID);
-    // assert_eq!(counter.value, 0);
-
-    // // Generate a new keypair to create an account owned by our program
-    // let program_owned_account = Keypair::new();
-    // let system_program_account = create_system_program_account_info();
-
-    // create_account(
-    //     &program_owned_account,
-    //     &system_program_account,
-    //     &payer.pubkey(),
-    //     &program::ID,
-    //     &[&payer, &system_program_account],
-    // )?;
-
-    // // Submit transfer with program transaction.
-    // let ix = with_program(payer.pubkey(), recipient.pubkey(), amount);
-    // let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
-    // let res = banks.process_transaction(tx).await;
-    // assert!(res.is_ok());
-
-    // // Verify counter was incremented.
-    // let counter_account = banks.get_account(counter_address).await.unwrap().unwrap();
-    // let counter = Counter::try_from_bytes(&counter_account.data).unwrap();
-    // assert_eq!(counter.value, 42);
+    let balance = banks.get_balance(recipient.pubkey()).await.unwrap();
+    assert_eq!(balance, amount);
 }
diff --git a/basics/transfer-sol/steel/tests/main.test.ts b/basics/transfer-sol/steel/tests/main.test.ts
@@ -0,0 +1,118 @@
+import { Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js';
+import { assert } from 'chai';
+import { describe, it } from 'mocha';
+import { BanksClient, ProgramTestContext, start } from 'solana-bankrun';
+
+const instructionDiscriminators = {
+  withCpi: Buffer.from([0]),
+  withProgram: Buffer.from([1]),
+};
+
+describe('transfer sol', async () => {
+  const PROGRAM_ID = new PublicKey('z7msBPQHDJjTvdQRoEcKyENgXDhSRYeHieN1ZMTqo35');
+
+  let context: ProgramTestContext;
+  let client: BanksClient;
+  let payer: Keypair;
+
+  before(async () => {
+    context = await start([{ name: 'transfer_sol_program', programId: PROGRAM_ID }], []);
+    client = context.banksClient;
+    payer = context.payer;
+  });
+
+  it('should transfer between accounts using our program', async () => {
+    // 1 SOL
+    const amount = 1 * LAMPORTS_PER_SOL;
+
+    // Generate a couple of keypairs to create accounts owned by our program
+    const acc1 = Keypair.generate();
+    const acc2 = Keypair.generate();
+
+    const createAccountIx = (pubkey: PublicKey) => {
+      return SystemProgram.createAccount({
+        fromPubkey: payer.publicKey,
+        newAccountPubkey: pubkey,
+        space: 0,
+        lamports: 2 * LAMPORTS_PER_SOL,
+        programId: PROGRAM_ID,
+      });
+    };
+
+    // Create the accounts
+    const createAccountsTx = new Transaction();
+    createAccountsTx.recentBlockhash = context.lastBlockhash;
+    createAccountsTx.add(createAccountIx(acc1.publicKey)).add(createAccountIx(acc2.publicKey)).sign(payer, acc1, acc2);
+
+    await client.processTransaction(createAccountsTx);
+
+    // Prepare the transfer instruction
+    const amountBuffer = Buffer.alloc(8);
+    amountBuffer.writeBigInt64LE(BigInt(amount), 0);
+
+    const data = Buffer.concat([instructionDiscriminators.withProgram, amountBuffer]);
+
+    const ix = new TransactionInstruction({
+      programId: PROGRAM_ID,
+      keys: [
+        { pubkey: acc1.publicKey, isSigner: false, isWritable: true },
+        { pubkey: acc2.publicKey, isSigner: false, isWritable: true },
+      ],
+      data,
+    });
+
+    // Prepare the transaction
+    const [blockHash, _] = await client.getLatestBlockhash();
+    const tx = new Transaction();
+    tx.recentBlockhash = blockHash;
+    tx.add(ix).sign(payer);
+
+    // Check initial balance
+    const initialRecipientBalance = await client.getBalance(acc2.publicKey);
+
+    // Execute the transaction
+    await client.processTransaction(tx);
+
+    // Check the balance
+    const finalRecipientBalance = await client.getBalance(acc2.publicKey);
+    assert.equal(finalRecipientBalance, initialRecipientBalance + BigInt(amount));
+  });
+
+  it('should transfer between accounts using the system programa', async () => {
+    // 1 SOL
+    const amount = 1 * LAMPORTS_PER_SOL;
+
+    // Generate a new keypair for the recipient
+    const recipient = Keypair.generate();
+
+    const amountBuffer = Buffer.alloc(8);
+    amountBuffer.writeBigInt64LE(BigInt(amount), 0);
+
+    // Prepare the instruction
+    const data = Buffer.concat([instructionDiscriminators.withCpi, amountBuffer]);
+
+    console.log(data);
+
+    const ix = new TransactionInstruction({
+      programId: PROGRAM_ID,
+      keys: [
+        { pubkey: payer.publicKey, isSigner: true, isWritable: true },
+        { pubkey: recipient.publicKey, isSigner: false, isWritable: true },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      ],
+      data,
+    });
+
+    // Prepare the transaction
+    const tx = new Transaction();
+    tx.recentBlockhash = context.lastBlockhash;
+    tx.add(ix).sign(payer);
+
+    // Execute the transaction
+    await client.processTransaction(tx);
+
+    // Check the balance
+    const recipientBalance = await client.getBalance(recipient.publicKey);
+    assert.equal(recipientBalance, BigInt(amount));
+  });
+});
