solana-ruby-web3js 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83aeed228731c11fa62b87f4ab5761a6715754921effc58400764bbe43378409
-  data.tar.gz: a0cd63b8a7998539304ce06ed69692e86361fece542033d63fab7383a692ebb3
+  metadata.gz: d2bd60b642f794a5923a3ff1d1b39e29e60aca6444445b0cf2e36e7393b18ff3
+  data.tar.gz: 95a61aab91ec4eaacb94fdc671027a2005b320b938a7a2132dc0daf9b643d45b
 SHA512:
-  metadata.gz: 29277d937c3201916bd0bd1eec7172621a4a83b2b21d5045afa5a285f4d757ba12de5f99031da0f0030e08e68adc4c7de1cb6a55301463cfb05f0b5e63072ffc
-  data.tar.gz: 0b627b741396f666e92fe8b032d859e944c933eda6b8ac7da29201d7913f116195b0751bcc2247537ca3a2b461bff9d2999ac234669e56a2708efe39776d881d
+  metadata.gz: 85acebeaeaebce2d39fe74f7d931a7e339e1a773d73f4774003a06a84bed4f94343b4f41269ac4bd1b2c7fbd186145ccba7d8d25b35b9aadee9a2b9f9a56c06e
+  data.tar.gz: 68b1d9bf25f64d1424e660387cc802e12842ea428547c4d4643b23489f2dab3db75c4d63a35d23159521b41634b11aef0befa9fa3193c2cf275f14f22412b70f

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,62 @@ 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}"
+

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,28 @@ 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
       }
     }
 
@@ -41,18 +58,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
 
 
@@ -74,14 +86,12 @@ module SolanaRuby
     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 +105,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 +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.1"
+  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

@@ -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,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
 

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.1
+  version: 2.0.2
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-28 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