solana-ruby-web3js 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f614bab0b21438c2820d0035a0aa33567a11fedd3ecb998666b39e5ab28681d
-  data.tar.gz: c63fd671d6328732c39994032f94aff219ff77eda8cd899c5d1f0c29f86f4524
+  metadata.gz: d2bd60b642f794a5923a3ff1d1b39e29e60aca6444445b0cf2e36e7393b18ff3
+  data.tar.gz: 95a61aab91ec4eaacb94fdc671027a2005b320b938a7a2132dc0daf9b643d45b
 SHA512:
-  metadata.gz: 4015bdc6179d57105ea1da82daa9d6ec19f623098d636271fb0e7ab9210d563414eae364271e58be82a2ce9ed6dc0804de53db7e7a15c5d353da4ff30faf5124
-  data.tar.gz: 8fca9ec2ccdcc5b3ea72f54fa6fad27fee3fe1aef20b145107382c523a0a70df90812f269fdcdee3d9d62b732e6ebe7ce6ad3e1514257d379db7088de55941d1
+  metadata.gz: 85acebeaeaebce2d39fe74f7d931a7e339e1a773d73f4774003a06a84bed4f94343b4f41269ac4bd1b2c7fbd186145ccba7d8d25b35b9aadee9a2b9f9a56c06e
+  data.tar.gz: 68b1d9bf25f64d1424e660387cc802e12842ea428547c4d4643b23489f2dab3db75c4d63a35d23159521b41634b11aef0befa9fa3193c2cf275f14f22412b70f

data/Gemfile.lock

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

data/README.md

@@ -332,3 +332,134 @@ The following methods are supported by the SolanaRuby::WebSocketClient:
 
 Several methods have optional parameters where default options are defined in the client. These options can be customized or overridden when calling the methods, but if left unspecified, the client will use its internal defaults.
 
+## Transaction Helpers
+
+### Transfer SOL Between Accounts
+
+To transfer SOL (the native cryptocurrency of the Solana blockchain) from one account to another, follow these steps:
+
+#### Requirements:
+
+- **Sender's Keypair:** Either generate a new keypair or provide the private key for an existing sender account. This keypair is used to sign the transaction.
+- **Receiver's Public Key:** Specify the public key of the destination account. You can generate a new keypair for the receiver or use an existing public key.
+- **Airdrop Functionality:** For Mainnet, Devnet, or Testnet transactions, ensure that the sender's account is funded with sufficient lamports using the Solana airdrop feature.
+- An initialized client to interact with the Solana blockchain.
+
+#### 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's 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]
+
+
+    # Airdrop some lamports to the sender's account when needed.
+    lamports = 10 * 1_000_000_000
+    sleep(1)
+    result = client.request_airdrop(sender_pubkey, lamports)
+    puts "Solana Balance #{lamports} lamports added sucessfully for the public key: #{sender_pubkey}"
+    sleep(10)
+
+
+    # Generate or use an existing receiver's public key
+    # Option 1: Generate a new keypair for the receiver
+    receiver_keypair = SolanaRuby::Keypair.generate
+    receiver_pubkey = receiver_keypair[:public_key]
+    # Option 2: Use an existing public key
+    # receiver_pubkey = 'InsertExistingPublicKeyHere'
+
+    transfer_lamports = 1 * 1_000_000
+    puts "Payer's full private key: #{sender_keypair[:full_private_key]}"
+    puts "Receiver's full private key: #{receiver_keypair[:full_private_key]}"
+    puts "Receiver's Public Key: #{receiver_keypair[:public_key]}"
+
+    # Create a new transaction
+    transaction = SolanaRuby::TransactionHelper.sol_transfer(
+      sender_pubkey,
+      receiver_pubkey,
+      transfer_lamports,
+      recent_blockhash
+    )
+
+    # Get the sender's private key (ensure it's a string)
+    private_key = sender_keypair[:private_key]
+    puts "Private key type: #{private_key.class}, Value: #{private_key.inspect}"
+
+    # Sign the transaction
+    signed_transaction = transaction.sign([sender_keypair])
+
+    # Send the transaction to the Solana network
+    sleep(5)
+    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}"
+

data/lib/solana_ruby/data_types/unsigned_int.rb

@@ -4,26 +4,26 @@ module SolanaRuby
       attr_reader :size
 
       BITS = {
-        8 => { directive: 'C*', size: 1 },
-        32 => { directive: 'L*', size: 4 },
-        64 => { directive: 'Q*', size: 8 }
+        8 => { directive: 'C', size: 1 },   # 8-bit unsigned integer
+        32 => { directive: 'L<', size: 4 }, # 32-bit little-endian unsigned integer
+        64 => { directive: 'Q<', size: 8 }  # 64-bit little-endian unsigned integer
       }
 
       def initialize(bits)
         @bits = bits
         type = BITS[@bits]
-        raise "Can only fit #{BITS.keys}" unless type
+        raise "Unsupported size. Supported sizes: #{BITS.keys.join(', ')} bits" unless type
         @size = type[:size]
         @directive = type[:directive]
       end
 
-      # Serialize the unsigned integer into bytes
+      # Serialize the unsigned integer into properly aligned bytes
       def serialize(obj)
         raise "Can only serialize integers" unless obj.is_a?(Integer)
-        raise "Cannot serialize negative integers" if obj < 0
+        raise "Cannot serialize negative integers" if obj.negative?
 
         if obj >= 256**@size
-          raise "Integer too large (does not fit in #{@size} bytes)"
+          raise "Integer too large to fit in #{@size} bytes"
         end
 
         [obj].pack(@directive).bytes
@@ -31,7 +31,7 @@ module SolanaRuby
 
       # Deserialize bytes into the unsigned integer
       def deserialize(bytes)
-        raise "Invalid serialization (wrong size)" if bytes.size != @size
+        raise "Invalid serialization (expected #{@size} bytes, got #{bytes.size})" if bytes.size != @size
 
         bytes.pack('C*').unpack(@directive).first
       end

data/lib/solana_ruby/data_types.rb

@@ -21,5 +21,9 @@ module SolanaRuby
     def blob1
       Blob.new(1)
     end
+
+    def blob32
+      Blob.new(32)
+    end
   end
 end

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,3 +1,6 @@
+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
     require 'rbnacl'
@@ -70,10 +73,10 @@ module SolanaRuby
       instructions.push(item)
     end
 
-    def sign(keys)
-      raise 'No signers' unless keys.any?
+    def sign(keypairs)
+      raise 'No signers' unless keypairs.any?
 
-      keys = keys.uniq{ |k| key[:public_key] }
+      keys = keypairs.uniq { |kp| kp[:public_key] }
       @signatures = keys.map do |key|
         {
           signature: nil,
@@ -114,15 +117,17 @@ module SolanaRuby
     def compile_message
       check_for_errors
       fetch_message_data
-      message = Message.new(
-        header: {
-          num_required_signatures: @num_required_signatures,
-          num_readonly_signed_accounts: @num_readonly_signed_accounts,
-          num_readonly_unsigned_accounts: @num_readonly_unsigned_accounts,
-        },
-        account_keys: @account_keys, recent_blockhash: recent_blockhash, instructions: @instructs
+
+      # add instruction structure
+      instructs = add_instructs
+      
+      message_data = Message.new(
+        header: @header,
+        account_keys: @account_keys,
+        recent_blockhash: recent_blockhash,
+        instructions: instructs
       )
-     message
+     message_data
     end
 
     def check_for_errors
@@ -168,11 +173,8 @@ module SolanaRuby
       # Split out signing from non-signing keys and count header values
       signed_keys = []
       unsigned_keys = []
-      header_params = split_keys(unique_metas, signed_keys, unsigned_keys)
+      @header = split_keys(unique_metas, signed_keys, unsigned_keys)
       @account_keys = signed_keys + unsigned_keys
-      
-      # add instruction structure
-      @instructs = add_instructs
     end
 
     def append_program_id(program_ids, account_metas)
@@ -245,19 +247,24 @@ module SolanaRuby
     end
 
     def split_keys(unique_metas, signed_keys, unsigned_keys)
-      @num_required_signatures = 0
-      @num_readonly_signed_accounts = 0
-      @num_readonly_unsigned_accounts = 0
+      num_required_signatures = 0
+      num_readonly_signed_accounts = 0
+      num_readonly_unsigned_accounts = 0
       unique_metas.each do |meta|
         if meta[:is_signer]
           signed_keys.push(meta[:pubkey])
-          @num_required_signatures += 1
-          @num_readonly_signed_accounts += 1 if (!meta[:is_writable])
+          num_required_signatures += 1
+          num_readonly_signed_accounts += 1 if (!meta[:is_writable])
         else
           unsigned_keys.push(meta[:pubkey])
-          @num_readonly_unsigned_accounts += 1 if (!meta[:is_writable])
+          num_readonly_unsigned_accounts += 1 if (!meta[:is_writable])
         end
       end
+      {
+        num_required_signatures: num_required_signatures,
+        num_readonly_signed_accounts: num_readonly_signed_accounts,
+        num_readonly_unsigned_accounts: num_readonly_unsigned_accounts,
+      }
     end
 
     def partial_sign(message, keys)

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,108 +20,202 @@ module SolanaRuby
         instruction: :uint8,
         amount: :uint64
       },
-       # Create account layout
+      # Create account layout
       create_account: {
-        instruction: :uint8,
+        instruction: :uint32,
         lamports: :uint64,
-        space: :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
       }
     }
 
     # Method to create a system account (e.g., for SPL token or SOL)
-    def self.create_account(from_pubkey, new_account_pubkey, lamports, space, owner_pubkey = SYSTEM_PROGRAM_ID)
-      instruction_data = encode_data(INSTRUCTION_LAYOUTS[:create_account], { instruction: 0, lamports: lamports, space: space })
-      create_account_instruction = TransactionInstruction.new(
-        keys: [
-          { pubkey: from_pubkey, is_signer: true, is_writable: true },
-          { pubkey: new_account_pubkey, is_signer: false, is_writable: true },
-          { pubkey: owner_pubkey, is_signer: false, is_writable: false }
-        ],
-        program_id: owner_pubkey,
-        data: instruction_data.bytes
+    def self.account_instruction(from_pubkey, new_account_pubkey, lamports, space, program_id)
+      # Encode the instruction data
+      instruction_data = encode_data(
+        INSTRUCTION_LAYOUTS[:create_account],
+        {
+          instruction: 0,      # '0' corresponds to the Create Account instruction
+          lamports: lamports,  # The amount of lamports to transfer to the new account
+          space: space,        # Amount of space allocated for the account's data
+          program_id: Base58.base58_to_binary(program_id, :bitcoin).bytes # Convert public key to binary
+        }
       )
-      create_account_instruction
+
+      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_instruction(keys, instruction_data, program_id)
     end
 
-    def self.create_and_sign_transaction(from_pubkey, new_account_pubkey, lamports, space, recent_blockhash)
+
+    def self.create_account(from_pubkey, new_account_pubkey, lamports, space, recent_blockhash, program_id = SYSTEM_PROGRAM_ID)
       # Create the transaction
       transaction = Transaction.new
       transaction.set_fee_payer(from_pubkey)
       transaction.set_recent_blockhash(recent_blockhash)
 
       # Add the create account instruction to the transaction
-      create_account_instruction = create_account(from_pubkey, new_account_pubkey, lamports, space)
-      transaction.add_instruction(create_account_instruction)
-
-      # You would then sign the transaction and send it as needed
-      # Example: signing and sending the transaction
+      instruction = account_instruction(from_pubkey, new_account_pubkey, lamports, space, program_id)
+      transaction.add_instruction(instruction)
+      
+      # return the transaction for signing
       transaction
     end
 
     # Method to create a SOL transfer instruction
-    def self.transfer_sol_transaction(from_pubkey, to_pubkey, lamports)
+    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
-    def self.new_sol_transaction(from_pubkey, to_pubkey, lamports, recent_blockhash)
+    def self.sol_transfer(from_pubkey, to_pubkey, lamports, recent_blockhash)
       transaction = Transaction.new
       transaction.set_fee_payer(from_pubkey)
       transaction.set_recent_blockhash(recent_blockhash)
-      transfer_instruction = transfer_sol_transaction(from_pubkey, to_pubkey, lamports)
+      transfer_instruction = transfer_sol_instruction(from_pubkey, to_pubkey, lamports)
       transaction.add_instruction(transfer_instruction)
       transaction
     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(from_pubkey, token_mint, owner_pubkey)
-      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: from_pubkey, is_signer: true, is_writable: true },
-          { pubkey: owner_pubkey, is_signer: false, is_writable: true },
-          { pubkey: token_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
@@ -134,5 +229,13 @@ module SolanaRuby
       layout = SolanaRuby::DataTypes::Layout.new(fields)
       layout.deserialize(data)
     end
+
+    def self.create_instruction(keys, data, toke_program_id = TOKEN_PROGRAM_ID)
+      TransactionInstruction.new(
+        keys: keys,
+        program_id: toke_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.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.0"
+  VERSION = "2.0.2"
 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/create_account.rb

@@ -3,30 +3,58 @@
 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 }
 
-# Testing Script
-
+# Initialize Solana client
 client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
 
 # Fetch the recent blockhash
 recent_blockhash = client.get_latest_blockhash["blockhash"]
+puts "Recent Blockhash: #{recent_blockhash}"
 
-# Generate a sender keypair and public key
-sender_keypair = SolanaRuby::Keypair.from_private_key("d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778")
+# Sender keypair and public 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]
-lamports = 1 * 1_000_000_000
-space = 165
-balance = client.get_balance(sender_pubkey)
-puts "sender account balance: #{balance}, wait for few seconds to update the balance in solana when the balance 0"
+puts "Sender Public Key: #{sender_pubkey}"
 
+# Check sender's account balance
+balance = client.get_balance(sender_pubkey)
+puts "Sender account balance: #{balance} lamports"
+if balance == 0
+  puts "Balance is zero, waiting for balance update..."
+  sleep(10)
+end
 
-# Generate a receiver keypair and public key
+# new keypair and public key (new account)
 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
+space = 165 # Space allocation (bytes)
+program_id = SolanaRuby::TransactionHelper::SYSTEM_PROGRAM_ID
+
+# Create and sign the transaction
+transaction = SolanaRuby::TransactionHelper.create_account(
+  sender_pubkey,
+  new_account_pubkey,
+  lamports,
+  space,
+  recent_blockhash,
+  program_id
+)
+
+# Sign transaction with both sender and new account keypairs
+transaction.sign([sender_keypair, new_account])
+
+# Send the transaction
+puts "Sending transaction..."
+response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
 
-# create a transaction instruction
-transaction = SolanaRuby::TransactionHelper.create_and_sign_transaction(sender_pubkey, new_account_pubkey, lamports, space, recent_blockhash)
+# Output transaction results
+puts "Transaction Signature: #{response}"
+puts "New account created successfully with Public Key: #{new_account_pubkey}"
 
-signed_transaction = transaction.sign([sender_keypair])
-sleep(5)
-response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
-puts "Response: #{response}"

data/transaction_testing/create_spl_token_account.rb

@@ -0,0 +1,52 @@
+# 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("2ce523e98cfd207a216a9ac4ef8b41c38c53a302af2022d2e89e1256d1b6a1d0")
+owner_pubkey = owner[:public_key]
+puts "owner public key: #{owner_pubkey}"
+puts "payer private key: #{owner[: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 = "5xxFuuvLiB6Gz3vbaqgkjf8fvEDXowftFiL14qUSgPiM"
+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,40 @@
+# 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 = "5FQhi6Kq3CKDaB3bus21ZqcL7wyeZNR18otFGoDfrZXU"
+destination_account = "C2wY5TKnj52S4s9yRUTNqitRe5gmFokSCoppJS6t63aa"
+mint_authority = SolanaRuby::Keypair.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
+amount = 1_000_000 # 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
 
@@ -35,7 +35,7 @@ puts "Receiver's full private key: #{keypair[:full_private_key]}"
 puts "Receiver's Public Key: #{keypair[:public_key]}"
 
 # Create a new transaction
-transaction = SolanaRuby::TransactionHelper.new_sol_transaction(
+transaction = SolanaRuby::TransactionHelper.sol_transfer(
   sender_pubkey,
   receiver_pubkey,
   transfer_lamports,

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.load_keypair('/Users/chinaputtaiahbellamkonda/.config/solana/id.json')
 fee_payer_pubkey = fee_payer[:public_key]
 lamports = 10 * 1_000_000_000
 space = 165
@@ -26,20 +26,23 @@ puts "sender account balance: #{balance}, wait for few seconds to update the bal
 # # Generate a receiver keypair and public key
 keypair = SolanaRuby::Keypair.generate
 receiver_pubkey = keypair[:public_key]
-transfer_lamports = 1 * 1_000_000
+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 = '9BvJGQC5FkLJzUC2TmYpi1iU8n9vt2388GLT5zvu8S1G'
+mint_address = 'G4JEi3UprH2rNz6hjBfQakLSR5EHXtS5Ry8MRFTQS5wG'
 token_program_id = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
 
 # Create a new transaction
 transaction = SolanaRuby::TransactionHelper.new_spl_token_transaction(
-  "9BvJGQC5FkLJzUC2TmYpi1iU8n9vt2388GLT5zvu8S1G",
+  "86w17eQHEoBcHY2rTdd5q9LjJL6Rx9QE6J1C9xgGkjt",
+  mint_address,
   receiver_pubkey,
   fee_payer_pubkey,
   transfer_lamports,
-  recent_blockhash
+  6,
+  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.0
+  version: 2.0.2
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-26 00:00:00.000000000 Z
+date: 2025-01-17 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,10 @@ 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/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 +290,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