solana-ruby-web3js 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f614bab0b21438c2820d0035a0aa33567a11fedd3ecb998666b39e5ab28681d
-  data.tar.gz: c63fd671d6328732c39994032f94aff219ff77eda8cd899c5d1f0c29f86f4524
+  metadata.gz: 83aeed228731c11fa62b87f4ab5761a6715754921effc58400764bbe43378409
+  data.tar.gz: a0cd63b8a7998539304ce06ed69692e86361fece542033d63fab7383a692ebb3
 SHA512:
-  metadata.gz: 4015bdc6179d57105ea1da82daa9d6ec19f623098d636271fb0e7ab9210d563414eae364271e58be82a2ce9ed6dc0804de53db7e7a15c5d353da4ff30faf5124
-  data.tar.gz: 8fca9ec2ccdcc5b3ea72f54fa6fad27fee3fe1aef20b145107382c523a0a70df90812f269fdcdee3d9d62b732e6ebe7ce6ad3e1514257d379db7088de55941d1
+  metadata.gz: 29277d937c3201916bd0bd1eec7172621a4a83b2b21d5045afa5a285f4d757ba12de5f99031da0f0030e08e68adc4c7de1cb6a55301463cfb05f0b5e63072ffc
+  data.tar.gz: 0b627b741396f666e92fe8b032d859e944c933eda6b8ac7da29201d7913f116195b0751bcc2247537ca3a2b461bff9d2999ac234669e56a2708efe39776d881d

data/Gemfile.lock

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

data/README.md

@@ -332,3 +332,75 @@ 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}"
+

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/transaction.rb

@@ -1,3 +1,5 @@
+Dir[File.join(__dir__, 'data_types', '*.rb')].each { |file| require file }
+
 module SolanaRuby
   class Transaction
     require 'rbnacl'
@@ -70,10 +72,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 +116,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 +172,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 +246,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

@@ -19,46 +19,59 @@ 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
       }
     }
 
     # 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 })
+    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
+        }
+      )
+
+      # Construct the transaction instruction
       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 }
+          { 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: owner_pubkey,
-        data: instruction_data.bytes
+        program_id: program_id,  # Use Solana's system program for account creation
+        data: instruction_data   # Encoded instruction data
       )
+
+      # return instruction data
       create_account_instruction
     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(
@@ -72,11 +85,11 @@ module SolanaRuby
     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
@@ -107,13 +120,14 @@ module SolanaRuby
     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)
+    def self.create_associated_token_account(payer, mint, owner)
       data = [0, 0, 0, 0]  # No data required for account creation
       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: 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 }
         ],

data/lib/solana_ruby/version.rb

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

data/transaction_testing/create_account.rb

@@ -3,30 +3,55 @@
 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_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}"
+
+# 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/sol_transfer.rb

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

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.1
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-26 00:00:00.000000000 Z
+date: 2024-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple