Clients and IDL

1
use anchor_lang::prelude::*;
2

3
declare_id!("6khKp4BeJpCjBY1Eh39ybiqbfRnrn2UzWeUARjQLXYRC");
4

5
#[program]
6
pub mod example {
7
    use super::*;
8

9
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
10
        let counter = &ctx.accounts.counter;
11
        msg!("Counter account created! Current count: {}", counter.count);
12
        Ok(())
13
    }
14

15
    pub fn increment(ctx: Context<Increment>) -> Result<()> {
16
        let counter = &mut ctx.accounts.counter;
17
        msg!("Previous counter: {}", counter.count);
18

19
        counter.count += 1;
20
        msg!("Counter incremented! Current count: {}", counter.count);
21
        Ok(())
22
    }
23
}
24

25
#[derive(Accounts)]
26
pub struct Initialize<'info> {
27
    #[account(mut)]
28
    pub payer: Signer<'info>,
29

30
    #[account(
31
        init,
32
        payer = payer,
33
        space = 8 + 8
34
    )]
35
    pub counter: Account<'info, Counter>,
36
    pub system_program: Program<'info, System>,
37
}
38

39
#[derive(Accounts)]
40
pub struct Increment<'info> {
41
    #[account(mut)]
42
    pub counter: Account<'info, Counter>,
43
}
44

45
#[account]
46
pub struct Counter {
47
    pub count: u64,
48
}

1
import {
2
  Connection,
3
  Keypair,
4
  LAMPORTS_PER_SOL,
5
  Transaction,
6
  sendAndConfirmTransaction,
7
} from '@solana/web3.js'
8
import { Program } from '@anchor-lang/core'
9
import type { Example } from './idl/example.ts'
10
import idl from './idl/example.json'
11

12
// Set up a connection to the cluster
13
const connection = new Connection('http://127.0.0.1:8899', 'confirmed')
14

15
// Create a Program instance using the IDL and connection
16
const program = new Program(idl as Example, {
17
  connection,
18
})
19

20
// Generate new Keypairs for the payer and the counter account
21
const payer = Keypair.generate()
22
const counter = Keypair.generate()
23

24
// Airdrop SOL to fund the payer's account for transaction fees
25
const airdropTransactionSignature = await connection.requestAirdrop(
26
  payer.publicKey,
27
  LAMPORTS_PER_SOL,
28
)
29
await connection.confirmTransaction(airdropTransactionSignature)
30

31
// Build the initialize instruction
32
const initializeInstruction = await program.methods
33
  .initialize()
34
  .accounts({
35
    payer: payer.publicKey,
36
    counter: counter.publicKey,
37
  })
38
  .instruction()
39

40
// Build the increment instruction
41
const incrementInstruction = await program.methods
42
  .increment()
43
  .accounts({
44
    counter: counter.publicKey,
45
  })
46
  .instruction()
47

48
// Add both instructions to a single transaction
49
const transaction = new Transaction().add(initializeInstruction, incrementInstruction)
50

51
// Send the transaction
52
const transactionSignature = await sendAndConfirmTransaction(connection, transaction, [
53
  payer,
54
  counter,
55
])
56
console.log('Transaction Signature', transactionSignature)
57

58
// Fetch the counter account
59
const counterAccount = await program.account.counter.fetch(counter.publicKey)
60
console.log('Count:', counterAccount.count)

1
use anchor_lang::prelude::*;
2

3
declare_id!("6khKp4BeJpCjBY1Eh39ybiqbfRnrn2UzWeUARjQLXYRC");
4

5
#[program]
6
pub mod example {
7
    use super::*;
8

9
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
10
        let counter = &ctx.accounts.counter;
11
        msg!("Counter account created! Current count: {}", counter.count);
12
        Ok(())
13
    }
14

15
    pub fn increment(ctx: Context<Increment>) -> Result<()> {
16
        let counter = &mut ctx.accounts.counter;
17
        msg!("Previous counter: {}", counter.count);
18

19
        counter.count += 1;
20
        msg!("Counter incremented! Current count: {}", counter.count);
21
        Ok(())
22
    }
23
}
24

25
#[derive(Accounts)]
26
pub struct Initialize<'info> {
27
    #[account(mut)]
28
    pub payer: Signer<'info>,
29

30
    #[account(
31
        init,
32
        payer = payer,
33
        space = 8 + 8
34
    )]
35
    pub counter: Account<'info, Counter>,
36
    pub system_program: Program<'info, System>,
37
}
38

39
#[derive(Accounts)]
40
pub struct Increment<'info> {
41
    #[account(mut)]
42
    pub counter: Account<'info, Counter>,
43
}
44

45
#[account]
46
pub struct Counter {
47
    pub count: u64,
48
}

{
  "address": "6khKp4BeJpCjBY1Eh39ybiqbfRnrn2UzWeUARjQLXYRC",
  "metadata": {
    "name": "example",
    "version": "0.1.0",
    "spec": "0.1.0",
    "description": "Created with Anchor"
  },
  "instructions": [
    {
      "name": "increment",
      "discriminator": [11, 18, 104, 9, 104, 174, 59, 33],
      "accounts": [
        {
          "name": "counter",
          "writable": true
        }
      ],
      "args": []
    },
21 collapsed lines
    {
      "name": "initialize",
      "discriminator": [175, 175, 109, 31, 13, 152, 155, 237],
      "accounts": [
        {
          "name": "payer",
          "writable": true,
          "signer": true
        },
        {
          "name": "counter",
          "writable": true,
          "signer": true
        },
        {
          "name": "system_program",
          "address": "11111111111111111111111111111111"
        }
      ],
      "args": []
    }
  ],
  "accounts": [
    {
      "name": "Counter",
      "discriminator": [255, 176, 4, 245, 188, 253, 124, 25]
    }
  ],
14 collapsed lines
  "types": [
    {
      "name": "Counter",
      "type": {
        "kind": "struct",
        "fields": [
          {
            "name": "count",
            "type": "u64"
          }
        ]
      }
    }
  ]
}

1
use anchor_client::{
2
    solana_client::rpc_client::RpcClient,
3
    solana_sdk::{
4
        commitment_config::CommitmentConfig, native_token::LAMPORTS_PER_SOL, signature::Keypair,
5
        system_program,
6
    },
7
    solana_signer::Signer,
8
    Client, Cluster,
9
};
10
use anchor_lang::prelude::*;
11
use std::rc::Rc;
12

13
declare_program!(example);
14
use example::{accounts::Counter, client::accounts, client::args};
15

16
#[tokio::main]
17
async fn main() -> anyhow::Result<()> {
18
    let connection = RpcClient::new_with_commitment(
19
        "http://127.0.0.1:8899", // Local validator URL
20
        CommitmentConfig::confirmed(),
21
    );
22

23
    // Generate Keypairs and request airdrop
24
    let payer = Keypair::new();
25
    let counter = Keypair::new();
26
    println!("Generated Keypairs:");
27
    println!("   Payer: {}", payer.pubkey());
28
    println!("   Counter: {}", counter.pubkey());
29

30
    println!("\nRequesting 1 SOL airdrop to payer");
31
    let airdrop_signature = connection.request_airdrop(&payer.pubkey(), LAMPORTS_PER_SOL)?;
32

33
    // Wait for airdrop confirmation
34
    while !connection.confirm_transaction(&airdrop_signature)? {
35
        std::thread::sleep(std::time::Duration::from_millis(100));
36
    }
37
    println!("   Airdrop confirmed!");
38

39
    // Create program client
40
    let provider = Client::new_with_options(
41
        Cluster::Localnet,
42
        Rc::new(payer),
43
        CommitmentConfig::confirmed(),
44
    );
45
    let program = provider.program(example::ID)?;
46

47
    // Build and send instructions
48
    println!("\nSend transaction with initialize and increment instructions");
49
    let initialize_ix = program
50
        .request()
51
        .accounts(accounts::Initialize {
52
            counter: counter.pubkey(),
53
            payer: program.payer(),
54
            system_program: system_program::ID,
55
        })
56
        .args(args::Initialize)
57
        .instructions()?
58
        .remove(0);
59

60
    let increment_ix = program
61
        .request()
62
        .accounts(accounts::Increment {
63
            counter: counter.pubkey(),
64
        })
65
        .args(args::Increment)
66
        .instructions()?
67
        .remove(0);
68

69
    let signature = program
70
        .request()
71
        .instruction(initialize_ix)
72
        .instruction(increment_ix)
73
        .signer(&counter)
74
        .send()
75
        .await?;
76
    println!("   Transaction confirmed: {}", signature);
77

78
    println!("\nFetch counter account data");
79
    let counter_account: Counter = program.account::<Counter>(counter.pubkey()).await?;
80
    println!("   Counter value: {}", counter_account.count);
81
    Ok(())
82
}

[package]
name = "client-example"
version = "0.1.0"
edition = "2021"

[dependencies]
anchor-client = { version = "1.0.1", features = ["async"] }
anchor-lang = "1.0.1"
anyhow = "1.0.93"
tokio = { version = "1.0", features = ["full"] }