solana-ruby-web3js 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2bd60b642f794a5923a3ff1d1b39e29e60aca6444445b0cf2e36e7393b18ff3
-  data.tar.gz: 95a61aab91ec4eaacb94fdc671027a2005b320b938a7a2132dc0daf9b643d45b
+  metadata.gz: 731b11629fcf8aeccddb1041dd5380b72ca120dd3ad23fc8cf1884a963864a96
+  data.tar.gz: d2d42348b2eb8d58433aec922bdcb3bb1631ab119d52999d4d20d63ebcf545ff
 SHA512:
-  metadata.gz: 85acebeaeaebce2d39fe74f7d931a7e339e1a773d73f4774003a06a84bed4f94343b4f41269ac4bd1b2c7fbd186145ccba7d8d25b35b9aadee9a2b9f9a56c06e
-  data.tar.gz: 68b1d9bf25f64d1424e660387cc802e12842ea428547c4d4643b23489f2dab3db75c4d63a35d23159521b41634b11aef0befa9fa3193c2cf275f14f22412b70f
+  metadata.gz: ace60d58b990d3364ff3397c0719a81089a5c73af584094ad4d1a673d55be52a9a6d60dab0db910b8f41ef4e01ce55b551ee0404b3aa075a12f1e4440ec96cbc
+  data.tar.gz: 9a26564405175ab409799becfeb8ea00d275689990b3319d379d6ae9df5d1c025d4ef925d21068664ce46a71f62a5abb07935b5732aa9eb5196addea4a36b5fa

data/README.md

@@ -463,3 +463,328 @@ The create_account helper allows creating a new account with specified parameter
     puts "Transaction Signature: #{response}"
     puts "New account created with Public Key: #{new_account_pubkey}"
 
+### SPL Token Account Creation
+
+The create_associated_token_account helper allows you to create an associated token account for a specific mint and owner. This is necessary when dealing with SPL tokens on the Solana blockchain.
+
+#### Requirements:
+
+- **Payer Public key**: The public key of the account funding the creation.
+- **Mint Public Key**: The public key of the SPL token mint.
+- **Owner Public Key**: The public key of the owner for whom the associated token account is being created.
+- **Recent Blockhash**: The latest blockhash for the transaction.
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Initialize the Solana client (defaults to Mainnet: https://api.mainnet-beta.solana.com)
+    client = SolanaRuby::HttpClient.new('https://api.devnet.solana.com')
+
+    # Fetch the recent blockhash
+    recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+    # Load the keypair for the payer
+    payer_keypair = SolanaRuby::Keypair.load_keypair('InsertYourJsonFilePathHere')
+    payer_pubkey = payer_keypair.public_key
+
+    # Generate or load the owner keypair
+    owner_keypair = SolanaRuby::Keypair.generate
+    owner_pubkey = owner_keypair.public_key
+
+    puts "Owner Public Key: #{owner_pubkey}"
+    puts "Owner Private Key: #{owner_keypair.private_key}"
+
+    # Define the mint public key for the SPL token
+    mint_pubkey = "InsertMintPublicKeyHere"
+
+    # Create the associated token account transaction
+    transaction = SolanaRuby::TransactionHelper.create_associated_token_account(
+      payer_pubkey,
+      mint_pubkey,
+      owner_pubkey,
+      recent_blockhash
+    )
+
+    # Sign the transaction
+    transaction.sign([payer_keypair])
+
+    # Send the transaction
+    response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+    # Output transaction results
+    puts "Transaction Signature: #{response}"
+
+### Close Account
+
+The close_account helper allows you to close an associated token account on the Solana blockchain. Any remaining balance in the account is transferred to the specified destination account.
+
+#### Requirements:
+
+- **Account to Close**: The public key of the associated token account to be closed.
+- **Destination Public Key**: The public key of the account receiving the remaining balance.
+- **Owner Public Key**: The public key of the account owner who has permission to close the account.
+- **Payer Public Key**: The public key of the account paying for the transaction fees.
+- **Multi-Signers (Optional)**: An array of additional signer public keys if the account requires multiple signatures.
+- **Recent Blockhash**: The latest blockhash for the transaction.
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Initialize the Solana client (defaults to Mainnet: https://api.mainnet-beta.solana.com)
+    client = SolanaRuby::HttpClient.new('https://api.devnet.solana.com')
+
+    # Fetch the recent blockhash
+    recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+    # Load the keypairs
+    payer_keypair = SolanaRuby::Keypair.from_private_key("InsertPayerPrivateKeyHere")
+    owner_keypair = SolanaRuby::Keypair.from_private_key("InsertOwnerPrivateKeyHere")
+
+    payer_pubkey = payer_keypair[:public_key]
+    owner_pubkey = owner_keypair[:public_key]
+
+    # Define the associated token account to be closed and the destination account
+    account_to_close_pubkey = 'InsertAccountToClosePublicKeyHere'  # Replace with the actual account to close
+    destination_pubkey = 'InsertDestinationPublicKeyHere'  # Replace with the actual recipient address
+
+    # Multi-signers (if required)
+    # multi_signers = [SolanaRuby::Keypair.from_private_key("InsertAdditionalSignerPrivateKeyHere")]
+    multi_signers = []
+
+    # Extract public keys of multi-signers
+    multi_signer_pubkeys = multi_signers.map { |signer| signer[:public_key] }
+
+    # Create the close account transaction
+    transaction = SolanaRuby::TransactionHelper.close_account(
+      account_to_close_pubkey,
+      destination_pubkey,
+      owner_pubkey,
+      payer_pubkey,
+      multi_signer_pubkeys,
+      recent_blockhash
+    )
+
+    # Sign the transaction
+    transaction.sign([payer_keypair, owner_keypair])
+
+    # Send the transaction
+    response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+    # Output transaction results
+    puts "Transaction Signature: #{response}"
+    puts "Closed account: #{account_to_close_pubkey}, funds sent to: #{destination_pubkey}"
+
+### Get Associated Token Address
+
+The get_associated_token_address helper fetches the associated token account for a given mint address and owner public key. This is essential when interacting with SPL tokens to determine where tokens are held.
+
+#### Requirements:
+
+- **Mint Address**: The public key of the SPL token mint.
+- **Owner Public Key**: The public key of the token holder.
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Define mint address and owner public key
+    mint_address = 'InsertMintPublicKeyHere'
+    owner_pubkey = 'InsertOwnerPublicKeyHere'
+
+    # Fetch associated token address
+    associated_token_address = SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(
+      mint_address,
+      owner_pubkey
+    )
+
+    puts "Associated Token Address: #{associated_token_address}"
+
+### Mint SPL Tokens
+
+The mint_spl_tokens helper allows you to mint new SPL tokens to a specified destination account. This is useful for token creators who need to distribute newly minted tokens.
+
+#### Requirements:
+
+- **Mint Account Public Key**: The public key of the mint account.
+- **Destination Account Public Key**: The associated token account where the newly minted tokens will be sent.
+- **Mint Authority Public Key**: The public key of the authority allowed to mint new tokens.
+- **Amount**: The number of tokens to mint (in the smallest unit, based on token decimals).
+- **Multi-Signers (Optional)**: Additional signer public keys if multi-signature authorization is required.
+- **Recent Blockhash**: The latest blockhash for the transaction.
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Initialize the Solana client (defaults to Mainnet: https://api.mainnet-beta.solana.com)
+    client = SolanaRuby::HttpClient.new('https://api.devnet.solana.com')
+
+    # Fetch the recent blockhash
+    recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+    # Define the mint account and recipient
+    mint_account = "InsertMintPublicKeyHere"
+    destination_account = "InsertDestinationPublicKeyHere"
+
+    # Load the mint authority keypair
+    mint_authority = SolanaRuby::Keypair.load_keypair('InsertYourJsonFilePathHere')
+
+    puts "Mint Authority Public Key: #{mint_authority[:public_key]}"
+
+    # Define the amount to mint (in smallest units)
+    amount = 1_000_000_00_00 # Adjust based on token decimals
+
+    # Multi-signers (if required)
+    multi_signers = [] # Example: [additional_signer_pubkey]
+
+    # Create the mint transaction
+    transaction = SolanaRuby::TransactionHelper.mint_spl_tokens(
+      mint_account,
+      destination_account,
+      mint_authority[:public_key],
+      amount,
+      recent_blockhash,
+      multi_signers
+    )
+
+    # Sign the transaction with the mint authority
+    transaction.sign([mint_authority])
+
+    # Send the transaction
+    response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+    # Output transaction results
+    puts "Transaction Signature: #{response}"
+    puts "Minted #{amount} tokens to: #{destination_account}"
+
+### Burn SPL Tokens
+
+The burn_spl_tokens helper allows you to burn (destroy) a specified amount of SPL tokens from a token account. This is typically used to reduce the total supply of a token.
+
+#### Requirements:
+
+- **Token Account**: The associated token account holding the tokens to be burned..
+- **Mint Address**: The mint address of the SPL token.
+- **Owner**: The owner of the token account (must have authority to burn tokens).
+- **Amount**: The number of tokens to burn (denominated in the smallest units).
+- **Recent Blockhash**: The latest blockhash for the transaction.
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Initialize the Solana client (defaults to Mainnet: https://api.mainnet-beta.solana.com)
+    client = SolanaRuby::HttpClient.new('https://api.devnet.solana.com')
+
+    # Fetch the recent blockhash
+    recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+    # Define token account and mint address
+    token_account = "InsertTokenAccountPublicKeyHere"
+    mint_address = "InsertMintPublicKeyHere"
+
+    # Load the mint authority keypair
+    mint_authority = SolanaRuby::Keypair.load_keypair('/path/to/id.json')
+    owner = mint_authority[:public_key]
+
+    # Define the amount to burn
+    amount = 500_000 # Tokens to burn in smallest units
+
+    # Create burn transaction
+    transaction = SolanaRuby::TransactionHelper.burn_spl_tokens(
+      token_account,
+      mint_address,
+      owner,
+      amount,
+      recent_blockhash
+    )
+
+    # Sign the transaction
+    transaction.sign([mint_authority])
+
+    # Send the transaction
+    response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+    # Output transaction results
+    puts "Transaction Signature: #{response}"
+
+### Transfer SPL Tokens
+
+The new_spl_token_transaction helper allows you to transfer SPL tokens from one associated token account to another.
+
+#### Requirements:
+
+- **Sender's Token Account**: The associated token account holding the tokens to be transferred.
+- **Mint Address**: The mint address of the SPL token.
+- **Receiver's Token Account**: The associated token account of the recipient.
+- **Fee Payer:**: The account responsible for transaction fees.
+- **Amount**: The number of tokens to mint (in the smallest unit, based on token decimals).
+- **Decimals**: The decimal precision of the SPL token (e.g., 9 for SOL-based tokens).
+- **Recent Blockhash**: The latest blockhash for the transaction.
+- **Multi-Signers (Optional)**: List of additional required signers (if applicable).
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Initialize the Solana client
+    client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
+
+    # Fetch the recent blockhash
+    recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+    # Load the fee payer's keypair
+    fee_payer = SolanaRuby::Keypair.from_private_key('InsertFeePayerPrivateKeyHere')
+    fee_payer_pubkey = fee_payer[:public_key]
+
+    # Define the SPL token mint address
+    mint_address = 'InsertMintPublicKeyHere'
+
+    # Define sender and receiver public keys
+    sender_pubkey = 'InsertSenderPublicKeyHere'
+    receiver_pubkey = 'InsertReceiverPublicKeyHere'
+
+    # Fetch the associated token accounts
+    senders_token_account = SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(mint_address, sender_pubkey)
+    receivers_token_account = SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(mint_address, receiver_pubkey)
+
+    puts "Sender's Token Account: #{senders_token_account}"
+    puts "Receiver's Token Account: #{receivers_token_account}"
+
+    # Define the transfer amount and decimals
+    transfer_lamports = 1_000_000 # Amount in smallest units
+    decimals = 9 # Adjust based on token precision
+
+    # Multi-signers (Optional, default is an empty array)
+    # multi_signers = [
+    #  SolanaRuby::Keypair.from_private_key('InsertMultiSigner1PrivateKeyHere'),
+    #  SolanaRuby::Keypair.from_private_key('InsertMultiSigner2PrivateKeyHere')
+    # ]
+    # multi_signer_pubkeys = multi_signers.map { |signer| signer[:public_key] }
+    multi_signers = []
+
+    # Create the transaction
+    transaction = SolanaRuby::TransactionHelper.new_spl_token_transaction(
+      senders_token_account,
+      mint_address,
+      receivers_token_account,
+      fee_payer_pubkey,
+      transfer_lamports,
+      decimals,
+      recent_blockhash,
+      multi_signer_pubkeys
+    )
+
+    # Sign the transaction (Only fee payer, unless multi-signers are provided)
+    transaction.sign([fee_payer] + multi_signers)
+
+    # Send the transaction
+    puts "Sending transaction..."
+    response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+    # Output transaction results
+    puts "Transaction Signature: #{response}"
+
+

data/lib/solana_ruby/transaction_helper.rb

@@ -42,6 +42,10 @@ module SolanaRuby
       spl_burn: {
         instruction: :uint8,
         amount: :uint64
+      },
+      # Close account layout (added here)
+      close_account: {
+        instruction: :uint8
       }
     }
 
@@ -82,6 +86,40 @@ module SolanaRuby
       transaction
     end
 
+    # Method to create a close account instruction
+    def self.close_account_instruction( account_to_close, destination, owner, payer, multi_signers)
+      # Encode the instruction data
+      instruction_data = encode_data(
+        INSTRUCTION_LAYOUTS[:close_account],
+        { instruction: 9 } # Close account instruction number is 9
+      )
+
+      signer = multi_signers.empty? ? payer : multi_signers
+      # Set up the keys for the close account instruction
+      keys = SolanaRuby::TransactionHelpers::TokenAccount.add_signers(
+        [{ pubkey: account_to_close, is_signer: false, is_writable: true },
+          { pubkey: destination, is_signer: false, is_writable: true }],
+          owner, signer)
+
+      # Return the instruction
+      create_instruction(keys, instruction_data)
+    end
+
+    # Method to close an account (helper)
+    def self.close_account(account_to_close, destination, owner, payer, multi_signers, recent_blockhash)
+      # Create the transaction
+      transaction = Transaction.new
+      transaction.set_fee_payer(payer)
+      transaction.set_recent_blockhash(recent_blockhash)
+
+      # Add the close account instruction to the transaction
+      instruction = close_account_instruction(account_to_close, destination, owner, payer, multi_signers)
+      transaction.add_instruction(instruction)
+
+      # Return the transaction for signing
+      transaction
+    end
+
     # Method to create a SOL transfer instruction
     def self.transfer_sol_instruction(from_pubkey, to_pubkey, lamports)
       fields = INSTRUCTION_LAYOUTS[:sol_transfer]
@@ -230,10 +268,10 @@ module SolanaRuby
       layout.deserialize(data)
     end
 
-    def self.create_instruction(keys, data, toke_program_id = TOKEN_PROGRAM_ID)
+    def self.create_instruction(keys, data, token_program_id = TOKEN_PROGRAM_ID)
       TransactionInstruction.new(
         keys: keys,
-        program_id: toke_program_id,
+        program_id: token_program_id,
         data: data
       )
     end

data/lib/solana_ruby/transaction_helpers/token_account.rb

@@ -27,7 +27,7 @@ module SolanaRuby
       end
 
       def self.add_signers(keys, owner_or_authority, multi_signers)
-        if multi_signers.any?
+        if multi_signers.is_a?(Array) && multi_signers.any?
           keys.push({ pubkey: owner_or_authority, is_signer: false, is_writable: false })
           multi_signers.each do |signer|
             pubkey = signer.is_a?(String) ? signer : signer.public_key

data/lib/solana_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolanaRuby
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

data/transaction_testing/close_acccount.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require 'pry'
+
+Dir[File.join(File.dirname(__dir__), 'lib/solana_ruby/*.rb')].each { |file| require file }
+Dir[File.join(File.dirname(__dir__), 'lib/solana_ruby/**/*.rb')].each { |file| require file }
+
+# SOL Transfer Testing Script
+
+# Initialize the Solana client
+client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
+
+# Fetch the recent blockhash
+recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+# Assuming you already have the following public keys
+payer = SolanaRuby::Keypair.from_private_key('7bcd98e0be17a23f5adbb199d614f5df28e2491ca9856a7efc276245d9d22f26')
+payer_pubkey = payer[:public_key]
+owner = SolanaRuby::Keypair.from_private_key('7bcd98e0be17a23f5adbb199d614f5df28e2491ca9856a7efc276245d9d22f26')
+account_to_close_pubkey = 'bnKvAbZzNjF123Wa9g4yQNva5adLqj2fLNfipZ2KgP6' # associated token account closing address 
+destination_pubkey = 'DCm6PCsdRoEXzHUdHxXnJTP65gYSPK5p8h9Cui3quiQQ' # associated token account receiving address
+
+# Create the transaction to close the account
+transaction = SolanaRuby::TransactionHelper.close_account(
+  account_to_close_pubkey, 
+  destination_pubkey,
+  owner[:public_key],
+  payer_pubkey,
+  [],
+  recent_blockhash
+)
+
+resp = transaction.sign([payer, owner])
+
+puts "signature: #{resp}"
+
+# Send the transaction
+puts "Sending transaction..."
+response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+# Output transaction results
+puts "Transaction Signature: #{response}"
+

data/transaction_testing/create_account.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-
+# require 'pry'
 Dir[File.join(File.dirname(__dir__), 'lib/solana_ruby/*.rb')].each { |file| require file }
 Dir[File.join(File.dirname(__dir__), 'lib/solana_ruby/**/*.rb')].each { |file| require file }
 

data/transaction_testing/create_spl_token_account.rb

@@ -16,10 +16,11 @@ payer_pubkey = payer[:public_key]
 
 # Generate a sender keypair and public key
 owner = SolanaRuby::Keypair.generate
-# owner = SolanaRuby::Keypair.from_private_key("2ce523e98cfd207a216a9ac4ef8b41c38c53a302af2022d2e89e1256d1b6a1d0")
+# owner = SolanaRuby::Keypair.from_private_key("4b9a36383e12d13581c37a50c38a00d91ae0e80f3ce25de852ea61f499102a33")
 owner_pubkey = owner[:public_key]
 puts "owner public key: #{owner_pubkey}"
-puts "payer private key: #{owner[:private_key]}"
+puts "owner private key: #{owner[:private_key]}"
+puts "owner full private key: #{owner[:full_private_key]}"
 
 # Airdrop some lamports to the sender's account
 # lamports = 10 * 1_000_000_000
@@ -29,7 +30,7 @@ puts "payer private key: #{owner[:private_key]}"
 # sleep(10)
 
 
-mint_pubkey = "5xxFuuvLiB6Gz3vbaqgkjf8fvEDXowftFiL14qUSgPiM"
+mint_pubkey = "InsertMintPublicKeyHere"
 program_id = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
 puts "payer public key: #{payer_pubkey}"
 

data/transaction_testing/mint_spl_tokens.rb

@@ -12,10 +12,13 @@ client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
 recent_blockhash = client.get_latest_blockhash["blockhash"]
 
 # Example parameters
-mint_account = "5FQhi6Kq3CKDaB3bus21ZqcL7wyeZNR18otFGoDfrZXU"
-destination_account = "C2wY5TKnj52S4s9yRUTNqitRe5gmFokSCoppJS6t63aa"
+mint_account = "2DoNkK31X9HH5MXY6pBeb3RDZ1ZDK7wgXrcvnyipXNvf"
+destination_account = "DCm6PCsdRoEXzHUdHxXnJTP65gYSPK5p8h9Cui3quiQQ"
 mint_authority = SolanaRuby::Keypair.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
-amount = 1_000_000 # Amount to mint in smallest units
+puts "Full private key: #{mint_authority[:full_private_key]}"
+puts "Private key: #{mint_authority[:private_key]}"
+puts "Public key: #{mint_authority[:public_key]}"
+amount = 1_000_000_00_00 # Amount to mint in smallest units
 multi_signers = [] # If multi-signature is used, include public keys here
 
 # Create a mint transaction

data/transaction_testing/spl_token_transfer.rb

@@ -13,7 +13,7 @@ client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
 recent_blockhash = client.get_latest_blockhash["blockhash"]
 
 # Generate a sender keypair and public key
-fee_payer = SolanaRuby::Keypair.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
+fee_payer = SolanaRuby::Keypair.from_private_key('e06f61b73aa625690ef97ed3704e8dc22bc835092e94cc9ae5650b516f26c91a')
 fee_payer_pubkey = fee_payer[:public_key]
 lamports = 10 * 1_000_000_000
 space = 165
@@ -24,23 +24,24 @@ puts "sender account balance: #{balance}, wait for few seconds to update the bal
 
 
 # # Generate a receiver keypair and public key
-keypair = SolanaRuby::Keypair.generate
+keypair = SolanaRuby::Keypair.from_private_key('f7173083807e1692e844aa2ec515eca18d016fc5e4468be75be20f6093de6641')
 receiver_pubkey = keypair[:public_key]
 transfer_lamports = 1_000_000
-# puts "Payer's full private key: #{sender_keypair[:full_private_key]}"
-# # puts "Receiver's full private key: #{keypair[:full_private_key]}"
-# # puts "Receiver's Public Key: #{keypair[:public_key]}"
-mint_address = 'G4JEi3UprH2rNz6hjBfQakLSR5EHXtS5Ry8MRFTQS5wG'
-token_program_id = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+mint_address = 'GDAWgGT42CqgaMds81JFVoqyJ4WBvfQsHAshPggAfXCM'
+
+senders_token_account = SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(mint_address, fee_payer_pubkey)
+receivers_token_account = SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(mint_address, receiver_pubkey)
+puts "senders_token_account: #{senders_token_account}"
+puts "receivers_token_account: #{receivers_token_account}"
 
 # Create a new transaction
 transaction = SolanaRuby::TransactionHelper.new_spl_token_transaction(
-  "86w17eQHEoBcHY2rTdd5q9LjJL6Rx9QE6J1C9xgGkjt",
+  senders_token_account,
   mint_address,
-  receiver_pubkey,
+  receivers_token_account,
   fee_payer_pubkey,
   transfer_lamports,
-  6,
+  9,
   recent_blockhash,
   []
 )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-web3js
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-17 00:00:00.000000000 Z
+date: 2025-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
@@ -263,6 +263,7 @@ files:
 - lib/solana_ruby/web_socket_methods/signature_methods.rb
 - lib/solana_ruby/web_socket_methods/slot_methods.rb
 - transaction_testing/burn_spl_tokens.rb
+- transaction_testing/close_acccount.rb
 - transaction_testing/create_account.rb
 - transaction_testing/create_spl_token_account.rb
 - transaction_testing/mint_spl_tokens.rb