solana-ruby-web3js 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83aeed228731c11fa62b87f4ab5761a6715754921effc58400764bbe43378409
-  data.tar.gz: a0cd63b8a7998539304ce06ed69692e86361fece542033d63fab7383a692ebb3
+  metadata.gz: 731b11629fcf8aeccddb1041dd5380b72ca120dd3ad23fc8cf1884a963864a96
+  data.tar.gz: d2d42348b2eb8d58433aec922bdcb3bb1631ab119d52999d4d20d63ebcf545ff
 SHA512:
-  metadata.gz: 29277d937c3201916bd0bd1eec7172621a4a83b2b21d5045afa5a285f4d757ba12de5f99031da0f0030e08e68adc4c7de1cb6a55301463cfb05f0b5e63072ffc
-  data.tar.gz: 0b627b741396f666e92fe8b032d859e944c933eda6b8ac7da29201d7913f116195b0751bcc2247537ca3a2b461bff9d2999ac234669e56a2708efe39776d881d
+  metadata.gz: ace60d58b990d3364ff3397c0719a81089a5c73af584094ad4d1a673d55be52a9a6d60dab0db910b8f41ef4e01ce55b551ee0404b3aa075a12f1e4440ec96cbc
+  data.tar.gz: 9a26564405175ab409799becfeb8ea00d275689990b3319d379d6ae9df5d1c025d4ef925d21068664ce46a71f62a5abb07935b5732aa9eb5196addea4a36b5fa

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    solana-ruby-web3js (2.0.0beta1)
+    solana-ruby-web3js (2.0.1)
       base58 (~> 0.2.3)
       base64 (~> 0.2.0)
       ed25519

data/README.md

@@ -404,3 +404,387 @@ To transfer SOL (the native cryptocurrency of the Solana blockchain) from one ac
     response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
     puts "Response: #{response}"
 
+### Account Creation
+
+The create_account helper allows creating a new account with specified parameters. This is commonly used to set up accounts for tokens, programs, or other allocations on the Solana blockchain.
+
+#### Requirements:
+
+- **Payer Public key**: The public key of the account funding the creation.
+- **New Account Public Key**: The public key of the account to be created.
+- **Lamports**: The amount of lamports to transfer to the new account.
+- **Space**: The amount of space (in bytes) to allocate for the new account.
+- **Recent Blockhash**: The latest blockhash for the transaction.
+- **Program Id**: The program ID associated with the new account (default: System Program).
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Initialize the 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"]
+
+    # Generate or fetch the sender/payer keypair
+    # Option 1: Generate a new keypair
+    sender_keypair = SolanaRuby::Keypair.generate
+    # Option 2: Use an existing private key
+    # sender_keypair = SolanaRuby::Keypair.from_private_key("InsertPrivateKeyHere")
+    sender_pubkey = sender_keypair[:public_key]
+
+    # Generate new account keypair 
+    new_account = SolanaRuby::Keypair.generate
+    new_account_pubkey = new_account[:public_key]
+
+    # Parameters for account creation
+    lamports = 1_000_000_000
+    space = 165
+    program_id = SolanaRuby::TransactionHelper::SYSTEM_PROGRAM_ID
+
+    # Create the account creation transaction
+    transaction = SolanaRuby::TransactionHelper.create_account(
+      sender_pubkey,
+      new_account_pubkey,
+      lamports,
+      space,
+      recent_blockhash,
+      program_id
+    )
+
+    # Sign with both keypairs
+    transaction.sign([sender_keypair, new_account])
+
+    # Send the transaction
+    response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+    # Output transaction results
+    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/ed25519_curve_checker.rb

@@ -0,0 +1,70 @@
+module SolanaRuby
+  class Ed25519CurveChecker
+    # Constants for Ed25519
+    P = 2**255 - 19
+    ONE = 1
+
+    # Main function to check if a public key is on the Ed25519 curve
+    def self.on_curve?(public_key_bytes)
+      # Validate public key length
+      return false unless public_key_bytes.bytesize == 32 # Public key must be 32 bytes
+
+      begin
+        # Decode the y-coordinate from the public key
+        y = decode_y(public_key_bytes)
+
+        # Validate if y is a quadratic residue on the curve equation
+        y_squared = (y * y) % P
+        numerator = (y_squared - 1) % P
+        denominator = (D * y_squared + 1) % P
+
+        # Ensure denominator isn't zero to avoid invalid computation
+        return false if denominator.zero?
+
+        # Calculate x_squared = numerator * modular_inverse(denominator, P) mod P
+        x_squared = (numerator * modular_inverse(denominator, P)) % P
+
+        # Check if x_squared is a valid quadratic residue
+        quadratic_residue?(x_squared)
+      rescue StandardError => e
+        puts "Error during curve check: #{e.message}"
+        false
+      end
+    end
+
+    private
+
+    # Decode the y-coordinate from the public key
+    def self.decode_y(public_key_bytes)
+      # Converts byte array directly to integer and maps it onto the curve's modulus
+      public_key_bytes.unpack1('H*').to_i(16) % P
+    end
+
+    # Determine if value is a quadratic residue modulo P
+    def self.quadratic_residue?(value)
+      # Quadratic residues satisfy value^((p - 1) / 2) mod P == 1
+      value.pow((P - 1) / 2, P) == 1
+    end
+
+    # Modular inverse using the Extended Euclidean Algorithm
+    def self.modular_inverse(value, mod_value)
+      t, new_t = 0, 1
+      r, new_r = mod_value, value
+
+      while new_r != 0
+        quotient = r / new_r
+        t, new_t = new_t, t - quotient * new_t
+        r, new_r = new_r, r - quotient * new_r
+      end
+
+      raise ArgumentError, 'Value has no modular inverse' if r > 1
+
+      t += mod_value if t.negative?
+      t % mod_value
+    end
+  end
+
+  # Calculate the Ed25519 constant D
+  # D = -121665 * modular_inverse(121666, P) mod P
+  D = (-121665 * Ed25519CurveChecker.modular_inverse(121666, Ed25519CurveChecker::P)) % Ed25519CurveChecker::P
+end

data/lib/solana_ruby/keypair.rb

@@ -6,16 +6,9 @@ module SolanaRuby
     # Generates a new Ed25519 keypair
     def self.generate
       signing_key = RbNaCl::Signatures::Ed25519::SigningKey.generate
-      public_key_bytes = signing_key.verify_key.to_bytes # Binary format for public key
       private_key_bytes = signing_key.to_bytes
-      private_key_hex = private_key_bytes.unpack1('H*') # Hex format for private key
 
-      # Convert public key binary to Base58 for readability and compatibility
-      {
-        public_key: Base58.binary_to_base58(public_key_bytes, :bitcoin),
-        private_key: private_key_hex,
-        full_private_key: Base58.binary_to_base58((private_key_bytes + public_key_bytes), :bitcoin)
-      }
+      keys(signing_key, private_key_bytes)
     end
 
     # Restores a keypair from a private key in hex format
@@ -28,8 +21,39 @@ module SolanaRuby
       # Initialize signing key
       signing_key = RbNaCl::Signatures::Ed25519::SigningKey.new(private_key_bytes)
 
+      keys(signing_key, private_key_bytes)
+    end
+
+    # Load a keypair from a JSON file
+    def self.load_keypair(file_path)
+      # Parse the JSON file
+      keypair_data = JSON.parse(File.read(file_path))
+
+      # Ensure it contains exactly 64 bytes for Ed25519 (32 private + 32 public)
+      raise "Invalid keypair length: expected 64 bytes, got #{keypair_data.length}" unless keypair_data.length == 64
+
+      # Convert the array to a binary string
+      private_key_bytes = keypair_data[0, 32].pack('C*')
+      public_key_bytes = keypair_data[32, 32].pack('C*')
+
+      # Create the signing key
+      signing_key = RbNaCl::Signatures::Ed25519::SigningKey.new(private_key_bytes)
+
+      # Verify the public key matches
+      raise "Public key mismatch" unless signing_key.verify_key.to_bytes == public_key_bytes
+
+      keys(signing_key, private_key_bytes)
+    rescue JSON::ParserError => e
+      raise "Failed to parse JSON file: #{e.message}"
+    end
+
+
+    private
+
+    def self.keys(signing_key, private_key_bytes)
       # Extract public key in binary format
       public_key_bytes = signing_key.verify_key.to_bytes
+      private_key_hex = private_key_bytes.unpack1('H*') # Hex format for private key
 
       # Return public key in Base58 format and private key in hex format
       {

data/lib/solana_ruby/public_key.rb

@@ -0,0 +1,62 @@
+require 'base58'
+require 'openssl'
+
+module SolanaRuby
+  class PublicKey
+    PUBLIC_KEY_LENGTH = 32
+
+    attr_reader :bn
+
+    def initialize(value)
+      case value
+      when PublicKey
+        @bn = value.bn
+      when String
+        decoded = decode_base58(value)
+        validate_length(decoded)
+        @bn = to_bn(decoded)
+      when Array
+        binary = value.pack('C*')
+        validate_length(binary)
+        @bn = to_bn(binary)
+      else
+        raise ArgumentError, "Unsupported input type: #{value.class}"
+      end
+    end
+
+    # Converts the public key to Base58
+    def to_base58
+      Base58.binary_to_base58(to_bytes, :bitcoin)
+    end
+
+    # Converts the public key to a binary string
+    def to_bytes
+      padded_bn = @bn.to_s(2) # Binary string from BigNum
+      if padded_bn.bytesize < PUBLIC_KEY_LENGTH
+        "\x00" * (PUBLIC_KEY_LENGTH - padded_bn.bytesize) + padded_bn
+      elsif padded_bn.bytesize > PUBLIC_KEY_LENGTH
+        raise "PublicKey byte length exceeds #{PUBLIC_KEY_LENGTH} bytes"
+      else
+        padded_bn
+      end
+    end
+
+    private
+
+    def decode_base58(value)
+      Base58.base58_to_binary(value, :bitcoin)
+    rescue ArgumentError => e
+      raise ArgumentError, "Invalid Base58 encoding: #{e.message}"
+    end
+
+    def validate_length(data)
+      unless data.bytesize == PUBLIC_KEY_LENGTH
+        raise ArgumentError, "Invalid public key length: expected #{PUBLIC_KEY_LENGTH} bytes, got #{data.bytesize}"
+      end
+    end
+
+    def to_bn(input)
+      OpenSSL::BN.new(input, 2)
+    end
+  end
+end

data/lib/solana_ruby/transaction.rb

@@ -1,4 +1,5 @@
 Dir[File.join(__dir__, 'data_types', '*.rb')].each { |file| require file }
+Dir[File.join(__dir__, 'transaction_helpers', '*.rb')].each { |file| require file }
 
 module SolanaRuby
   class Transaction

data/lib/solana_ruby/transaction_helper.rb

@@ -1,12 +1,13 @@
 module SolanaRuby
   class TransactionHelper
     require 'base58'
-    require 'pry'
 
     # Constants for program IDs
     SYSTEM_PROGRAM_ID = '11111111111111111111111111111111'
     TOKEN_PROGRAM_ID = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
-    ASSOCIATED_TOKEN_PROGRAM_ID = 'ATokenGP3evbxxpQ7bYPLNNaxD2c4bqtvWjpKbmz6HjH'
+    ASSOCIATED_TOKEN_PROGRAM_ID = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL'
+    SYSVAR_RENT_ID = 'SysvarRent111111111111111111111111111111111'
+
 
     INSTRUCTION_LAYOUTS = {
       # Native SOL transfer
@@ -19,12 +20,32 @@ module SolanaRuby
         instruction: :uint8,
         amount: :uint64
       },
-    # Create account layout
+      # Create account layout
       create_account: {
         instruction: :uint32,
         lamports: :uint64,
         space: :uint64,
         program_id: :blob32
+      },
+      # SPL token transfer_checked
+      spl_transfer_checked: {
+        instruction: :uint8,
+        amount: :uint64,
+        decimals: :uint8
+      },
+      # mint spl tokens
+      spl_mint_to: {
+        instruction: :uint8,
+        amount: :uint64
+      },
+      # burn spl tokens
+      spl_burn: {
+        instruction: :uint8,
+        amount: :uint64
+      },
+      # Close account layout (added here)
+      close_account: {
+        instruction: :uint8
       }
     }
 
@@ -41,18 +62,13 @@ module SolanaRuby
         }
       )
 
-      # Construct the transaction instruction
-      create_account_instruction = TransactionInstruction.new(
-        keys: [
-          { pubkey: from_pubkey, is_signer: true, is_writable: true },  # Funder's account
-          { pubkey: new_account_pubkey, is_signer: true, is_writable: true } # New account
-        ],
-        program_id: program_id,  # Use Solana's system program for account creation
-        data: instruction_data   # Encoded instruction data
-      )
+      keys = [
+        { pubkey: from_pubkey, is_signer: true, is_writable: true },  # Funder's account
+        { pubkey: new_account_pubkey, is_signer: true, is_writable: true } # New account
+      ]
 
       # return instruction data
-      create_account_instruction
+      create_instruction(keys, instruction_data, program_id)
     end
 
 
@@ -70,18 +86,50 @@ 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]
       data = encode_data(fields, { instruction: 2, lamports: lamports })
-      TransactionInstruction.new(
-        keys: [
+      keys = [
           { pubkey: from_pubkey, is_signer: true, is_writable: true },
           { pubkey: to_pubkey, is_signer: false, is_writable: true }
-        ],
-        program_id: SYSTEM_PROGRAM_ID,
-        data: data
-      )
+        ]
+
+      create_instruction(keys, data, SYSTEM_PROGRAM_ID)
     end
 
     # Helper to create a new transaction for SOL transfer
@@ -95,46 +143,117 @@ module SolanaRuby
     end
 
     # Method to create an SPL token transfer instruction
-    def self.transfer_spl_token(source, destination, owner, amount)
-      fields = INSTRUCTION_LAYOUTS[:spl_transfer]
-      data = encode_data(fields, { instruction: 3, amount: amount }) # Instruction type 3: Transfer tokens
-      TransactionInstruction.new(
-        keys: [
-          { pubkey: source, is_signer: false, is_writable: true },
-          { pubkey: destination, is_signer: false, is_writable: true },
-          { pubkey: owner, is_signer: true, is_writable: false }
-        ],
-        program_id: TOKEN_PROGRAM_ID,
-        data: data
-      )
+    def self.transfer_spl_token(source, token, destination, owner, amount, decimals, multi_signers)
+      fields = INSTRUCTION_LAYOUTS[:spl_transfer_checked]
+      data = encode_data(fields, { instruction: 12, amount: amount, decimals: decimals }) # Instruction type 3: Transfer tokens
+      keys = SolanaRuby::TransactionHelpers::TokenAccount.add_signers(
+        [{ pubkey: source, is_signer: false, is_writable: true },
+          { pubkey: token, is_signer: false, is_writable: false },
+          { pubkey: destination, is_signer: false, is_writable: true }],
+          owner, multi_signers)
+      
+      create_instruction(keys, data)
     end
 
     # Helper to create a new transaction for SPL token transfer
-    def self.new_spl_token_transaction(source, destination, owner, amount, recent_blockhash)
+    def self.new_spl_token_transaction(source, mint, destination, owner, amount, decimals, recent_blockhash, multi_signers=[])
       transaction = Transaction.new
       transaction.set_fee_payer(owner)
       transaction.set_recent_blockhash(recent_blockhash)
-      transfer_instruction = transfer_spl_token(source, destination, owner, amount)
+      transfer_instruction = transfer_spl_token(source, mint, destination, owner, amount, decimals, multi_signers)
       transaction.add_instruction(transfer_instruction)
       transaction
     end
 
-    # Method to create an associated token account for a given token mint
-    def self.create_associated_token_account(payer, mint, owner)
-      data = [0, 0, 0, 0]  # No data required for account creation
+    # Method to create an associated token account
+    def self.create_associated_token_account(payer, mint, owner, recent_blockhash, program_id = SYSTEM_PROGRAM_ID)
+      transaction = Transaction.new
+      transaction.set_fee_payer(payer)  # Payer funds the transaction
+      transaction.set_recent_blockhash(recent_blockhash)
+
+      # Derive the associated token account address
+      associated_token_account_pubkey = SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(mint, owner)
+      puts "associated_token_account_pubkey: #{associated_token_account_pubkey}"
+
+      
+      # Create the associated token account instruction
       create_account_instruction = TransactionInstruction.new(
         keys: [
-          { pubkey: payer, is_signer: true, is_writable: true },
-          { pubkey: associated_token, is_signer: false, is_writable: true },
-          { pubkey: owner, is_signer: false, is_writable: false },
-          { pubkey: mint, is_signer: false, is_writable: false },
-          { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, is_signer: false, is_writable: false },
-          { pubkey: SYSTEM_PROGRAM_ID, is_signer: false, is_writable: false }
+          { pubkey: payer, is_signer: true, is_writable: true },                 # Payer account
+          { pubkey: associated_token_account_pubkey, is_signer: false, is_writable: true },  # New ATA
+          { pubkey: owner, is_signer: false, is_writable: false },               # Owner of the ATA
+          { pubkey: mint, is_signer: false, is_writable: false },                # Token mint
+          { pubkey: SYSTEM_PROGRAM_ID, is_signer: false, is_writable: false },   # System program
+          { pubkey: TOKEN_PROGRAM_ID, is_signer: false, is_writable: false },   # Token program
+          { pubkey: SYSVAR_RENT_ID, is_signer: false, is_writable: false }
         ],
         program_id: ASSOCIATED_TOKEN_PROGRAM_ID,
-        data: data
+        data: []  # No data required for creating an associated token account
       )
-      create_account_instruction
+
+      # Add the instruction to the transaction
+      transaction.add_instruction(create_account_instruction)
+      transaction
+    end
+
+    # Method to create a mint instruction for SPL tokens
+    def self.mint_spl_token(mint, destination, mint_authority, amount, multi_signers = [])
+      fields = INSTRUCTION_LAYOUTS[:spl_mint_to]
+      data = encode_data(fields, { instruction: 7, amount: amount }) # Instruction type 7: Mint to
+      keys = SolanaRuby::TransactionHelpers::TokenAccount.add_signers(
+        [{ pubkey: mint, is_signer: false, is_writable: true },
+          { pubkey: destination, is_signer: false, is_writable: true }],
+          mint_authority, multi_signers)
+
+      create_instruction(keys, data)
+    end
+
+    # Helper to create a transaction for minting SPL tokens
+    def self.mint_spl_tokens(mint, destination, mint_authority, amount, recent_blockhash, multi_signers = [])
+      transaction = Transaction.new
+      transaction.set_fee_payer(mint_authority)
+      transaction.set_recent_blockhash(recent_blockhash)
+      mint_instruction = mint_spl_token(mint, destination, mint_authority, amount, multi_signers)
+      transaction.add_instruction(mint_instruction)
+      transaction
+    end
+
+    # Method to create a burn instruction for SPL tokens
+    def self.burn_spl_token(token_account, mint, mint_authority, amount, multi_signers = [])
+      # Define the fields for the burn instruction
+      fields = INSTRUCTION_LAYOUTS[:spl_burn]
+      
+      # Encode the instruction data
+      data = encode_data(fields, { instruction: 8, amount: amount }) # Instruction type 8: Burn
+
+      keys = SolanaRuby::TransactionHelpers::TokenAccount.add_signers(
+        [
+          { pubkey: token_account, is_signer: false, is_writable: true }, # Token account holding tokens to burn
+          { pubkey: mint, is_signer: false, is_writable: true }          # Mint address
+        ], mint_authority, multi_signers)
+
+      # Return the transaction instruction
+      create_instruction(keys, data)
+    end
+
+    # Helper to create a transaction for burning SPL tokens
+    def self.burn_spl_tokens(token_account, mint, owner, amount, recent_blockhash, multi_signers = [])
+      # Create a new transaction
+      transaction = Transaction.new
+      transaction.set_fee_payer(owner)
+      transaction.set_recent_blockhash(recent_blockhash)
+
+      # Add the burn instruction to the transaction
+      burn_instruction = burn_spl_token(token_account, mint, owner, amount, multi_signers)
+      transaction.add_instruction(burn_instruction)
+
+      # Return the transaction for signing
+      transaction
+    end
+
+    # Derive the associated token account address
+    def self.get_associated_token_address(mint, owner, program_id)
+      SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(mint, owner, program_id)
     end
 
     # Utility to encode data using predefined layouts
@@ -148,5 +267,13 @@ module SolanaRuby
       layout = SolanaRuby::DataTypes::Layout.new(fields)
       layout.deserialize(data)
     end
+
+    def self.create_instruction(keys, data, token_program_id = TOKEN_PROGRAM_ID)
+      TransactionInstruction.new(
+        keys: keys,
+        program_id: token_program_id,
+        data: data
+      )
+    end
   end
 end

data/lib/solana_ruby/transaction_helpers/token_account.rb

@@ -0,0 +1,73 @@
+module SolanaRuby
+  module TransactionHelpers
+    class TokenAccount
+      # Associated Token Program ID
+      ASSOCIATED_TOKEN_PROGRAM_ID = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL'.freeze
+
+      # Token Program ID
+      TOKEN_PROGRAM_ID = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'.freeze
+
+      def self.get_associated_token_address(mint, payer)
+        mint_bytes = Base58.base58_to_binary(mint, :bitcoin)
+        payer_bytes = Base58.base58_to_binary(payer, :bitcoin)
+        associated_program_bytes = Base58.base58_to_binary(ASSOCIATED_TOKEN_PROGRAM_ID, :bitcoin)
+
+        # Derive associated token account PDA
+        seeds = [
+          payer_bytes,
+          Base58.base58_to_binary(TOKEN_PROGRAM_ID, :bitcoin),
+          mint_bytes
+        ]
+        
+        # Attempt to find the first valid off-curve PDA
+        associated_token_account_pubkey = find_program_address(seeds, associated_program_bytes)
+
+        # Return the computed Base58 PDA string
+        Base58.binary_to_base58(associated_token_account_pubkey, :bitcoin)
+      end
+
+      def self.add_signers(keys, owner_or_authority, multi_signers)
+        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
+            keys.push({ pubkey: pubkey, is_signer: true, is_writable: false })
+          end
+        else
+          keys.push({ pubkey: owner_or_authority, is_signer: true, is_writable: false })
+        end
+        keys
+      end
+
+      private
+
+      def self.find_program_address(seeds, program_id)
+        nonce = 255
+        loop do
+          # Combine the current nonce with the seeds
+          seeds_with_nonce = seeds + [[nonce].pack('C*')]
+          hashed_buffer = hash_seeds(seeds_with_nonce, program_id)
+
+          # Debugging: Log every generated address for inspection
+          puts "Testing nonce #{nonce}: #{Base58.binary_to_base58(hashed_buffer, :bitcoin)}"
+
+          # Check if it's valid and off-curve
+          if !SolanaRuby::Ed25519CurveChecker.on_curve?(hashed_buffer)
+            puts "Found valid PDA with nonce #{nonce}: #{Base58.binary_to_base58(hashed_buffer, :bitcoin)}"
+            return hashed_buffer
+          end
+
+          # Decrement nonce safely
+          nonce -= 1
+          raise "Unable to find a valid PDA address off the curve" if nonce < 0
+        end
+      end
+
+      def self.hash_seeds(seeds, program_id)
+        # Combine seeds and program ID with the PDA derivation logic
+        buffer = seeds.flatten.join + program_id + "ProgramDerivedAddress"
+        RbNaCl::Hash.sha256(buffer)
+      end
+    end
+  end
+end

data/lib/solana_ruby/version.rb

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

data/lib/solana_ruby.rb

@@ -2,7 +2,6 @@
 
 Dir[File.join(__dir__, 'solana_ruby', '*.rb')].each { |file| require file }
 # Dir["solana_ruby/*.rb"].each { |f| require_relative f.delete(".rb") }
-require 'pry'
 module SolanaRuby
   class Error < StandardError; end
 end

data/transaction_testing/burn_spl_tokens.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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"]
+token_account = "C2wY5TKnj52S4s9yRUTNqitRe5gmFokSCoppJS6t63aa"
+mint_address = "5FQhi6Kq3CKDaB3bus21ZqcL7wyeZNR18otFGoDfrZXU"
+mint_authority = SolanaRuby::Keypair.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
+owner = mint_authority[:public_key]
+amount = 500_000 # Number of tokens to burn
+
+transaction = SolanaRuby::TransactionHelper.burn_spl_tokens(
+  token_account,
+  mint_address,
+  owner,
+  amount,
+  recent_blockhash
+)
+
+# Sign and send the transaction
+resp = transaction.sign([mint_authority])
+
+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/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 }
 
@@ -11,8 +11,9 @@ recent_blockhash = client.get_latest_blockhash["blockhash"]
 puts "Recent Blockhash: #{recent_blockhash}"
 
 # Sender keypair and public key
-private_key = "d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778"
-sender_keypair = SolanaRuby::Keypair.from_private_key(private_key)
+# private_key = "d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778"
+# sender_keypair = SolanaRuby::Keypair.from_private_key(private_key)
+sender_keypair = SolanaRuby::Keypair.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
 sender_pubkey = sender_keypair[:public_key]
 puts "Sender Public Key: #{sender_pubkey}"
 
@@ -28,6 +29,8 @@ end
 new_account = SolanaRuby::Keypair.generate
 new_account_pubkey = new_account[:public_key]
 puts "New Account Public Key: #{new_account_pubkey}"
+puts "New Account Private Key: #{new_account[:private_key]}"
+puts "New Account Full Private Key: #{new_account[:full_private_key]}"
 
 # Parameters for account creation
 lamports = 1 * 1_000_000_000 # Lamports to transfer

data/transaction_testing/create_spl_token_account.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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"]
+
+payer = SolanaRuby::Keypair.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
+payer_pubkey = payer[:public_key]
+
+# Generate a sender keypair and public key
+owner = SolanaRuby::Keypair.generate
+# owner = SolanaRuby::Keypair.from_private_key("4b9a36383e12d13581c37a50c38a00d91ae0e80f3ce25de852ea61f499102a33")
+owner_pubkey = owner[:public_key]
+puts "owner public key: #{owner_pubkey}"
+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
+# sleep(1)
+# result = client.request_airdrop(payer_pubkey, lamports)
+# puts "Solana Balance #{lamports} lamports added sucessfully for the public key: #{payer_pubkey}"
+# sleep(10)
+
+
+mint_pubkey = "InsertMintPublicKeyHere"
+program_id = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+puts "payer public key: #{payer_pubkey}"
+
+# associated_token_address = SolanaRuby::TransactionHelpers::TokenAccount.get_associated_token_address(mint_pubkey, payer_pubkey, program_id)
+
+# puts "Associated Token Address: #{associated_token_address}"
+
+transaction = SolanaRuby::TransactionHelper.create_associated_token_account(payer_pubkey, mint_pubkey, owner_pubkey, recent_blockhash)
+
+resp = transaction.sign([payer])
+
+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/mint_spl_tokens.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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"]
+
+# Example parameters
+mint_account = "2DoNkK31X9HH5MXY6pBeb3RDZ1ZDK7wgXrcvnyipXNvf"
+destination_account = "DCm6PCsdRoEXzHUdHxXnJTP65gYSPK5p8h9Cui3quiQQ"
+mint_authority = SolanaRuby::Keypair.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
+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
+transaction = SolanaRuby::TransactionHelper.mint_spl_tokens(
+  mint_account,
+  destination_account,
+  mint_authority[:public_key],
+  amount,
+  recent_blockhash,
+  multi_signers
+)
+
+resp = transaction.sign([mint_authority])
+
+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/sol_transfer.rb

@@ -1,6 +1,6 @@
 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 }
-require 'pry'
+# require 'pry'
 
 # SOL Transfer Testing Script
 

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.from_private_key("d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778")
+fee_payer = SolanaRuby::Keypair.from_private_key('e06f61b73aa625690ef97ed3704e8dc22bc835092e94cc9ae5650b516f26c91a')
 fee_payer_pubkey = fee_payer[:public_key]
 lamports = 10 * 1_000_000_000
 space = 165
@@ -24,22 +24,26 @@ 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 * 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 = '9BvJGQC5FkLJzUC2TmYpi1iU8n9vt2388GLT5zvu8S1G'
-token_program_id = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+transfer_lamports = 1_000_000
+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(
-  "9BvJGQC5FkLJzUC2TmYpi1iU8n9vt2388GLT5zvu8S1G",
-  receiver_pubkey,
+  senders_token_account,
+  mint_address,
+  receivers_token_account,
   fee_payer_pubkey,
   transfer_lamports,
-  recent_blockhash
+  9,
+  recent_blockhash,
+  []
 )
 # # Get the sender's private key (ensure it's a string)
 private_key = fee_payer[:private_key]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-web3js
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-28 00:00:00.000000000 Z
+date: 2025-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
@@ -235,6 +235,7 @@ files:
 - lib/solana_ruby/data_types/near_int64.rb
 - lib/solana_ruby/data_types/sequence.rb
 - lib/solana_ruby/data_types/unsigned_int.rb
+- lib/solana_ruby/ed25519_curve_checker.rb
 - lib/solana_ruby/http_client.rb
 - lib/solana_ruby/http_methods/account_methods.rb
 - lib/solana_ruby/http_methods/basic_methods.rb
@@ -247,8 +248,10 @@ files:
 - lib/solana_ruby/http_methods/transaction_methods.rb
 - lib/solana_ruby/keypair.rb
 - lib/solana_ruby/message.rb
+- lib/solana_ruby/public_key.rb
 - lib/solana_ruby/transaction.rb
 - lib/solana_ruby/transaction_helper.rb
+- lib/solana_ruby/transaction_helpers/token_account.rb
 - lib/solana_ruby/transaction_instruction.rb
 - lib/solana_ruby/utils.rb
 - lib/solana_ruby/version.rb
@@ -259,7 +262,11 @@ files:
 - lib/solana_ruby/web_socket_methods/root_methods.rb
 - 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
 - transaction_testing/sol_transfer.rb
 - transaction_testing/spl_token_transfer.rb
 homepage: https://github.com/Build-Squad/solana-ruby
@@ -284,7 +291,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
+rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
 summary: Solana Ruby SDK