solana-ruby-web3js 2.0.0beta1 → 2.0.0beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37360e6f27ca521194022c29c3419d2dc06e5dcae0499af04892e3ca29299b0d
-  data.tar.gz: c5748b0ddacfaa170e79aba9a16b883c64a05ac7f776f0589c3914a5ad418356
+  metadata.gz: 6bb6650de7a5beae14649fe9cfac20973923d0be4c4f74e9d1e8f373e70842b9
+  data.tar.gz: c3ad4316d61d4326327bb281a3eb64991011ae14d51a7974de6eaf9705d4ffa5
 SHA512:
-  metadata.gz: 683573ae5898ae932dea765b65cc4d73136f198429920be4e923da76bfed3b515e941f96761238f42dd92cedadc7d28c03f43dc3357fb07451a4940b3a2e93e0
-  data.tar.gz: e6c3b0e84760561c6b22290f3dab047cb041f9de7ed02d1a7cd88cc5ed285a6fb5c2ca97e7a719f709044c044b3c769aa0d0c612bb35b5894e0e70f1955e9c4e
+  metadata.gz: 94c8304f1d05d7cbd8ec22947d98ede21c1892b210ad5cdb43f3e6293f4c6ab288c8aa83b1ba6e40a28d08a191a32ba775966eeb370631d02112cac981309fb6
+  data.tar.gz: '0085b47b4f44786e0bd0af77827a12cbc191744a16aff61448cafff641a53efa798677ef51b3748966f76547b883fd767d3f48ffe5297f8519cc08eb1ee81e90'

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

@@ -342,7 +342,7 @@ To transfer SOL (the native cryptocurrency of the Solana blockchain) from one ac
 
 - **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 Devnet or Testnet transactions, ensure that the sender's account is funded with sufficient lamports using the Solana airdrop feature.
+- **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:
@@ -364,7 +364,7 @@ To transfer SOL (the native cryptocurrency of the Solana blockchain) from one ac
     sender_pubkey = sender_keypair[:public_key]
 
 
-    # Airdrop some lamports to the sender's account
+    # 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)
@@ -374,7 +374,7 @@ To transfer SOL (the native cryptocurrency of the Solana blockchain) from one ac
 
     # Generate or use an existing receiver's public key
     # Option 1: Generate a new keypair for the receiver
-    receiver_keypair = SolanaRuby::Keypair.generate # generate receiver keypair
+    receiver_keypair = SolanaRuby::Keypair.generate
     receiver_pubkey = receiver_keypair[:public_key]
     # Option 2: Use an existing public key
     # receiver_pubkey = 'InsertExistingPublicKeyHere'
@@ -385,7 +385,7 @@ To transfer SOL (the native cryptocurrency of the Solana blockchain) from one ac
     puts "Receiver's Public Key: #{receiver_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/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

@@ -72,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,
@@ -116,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
@@ -170,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)
@@ -247,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.0beta1"
+  VERSION = "2.0.0beta2"
 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

@@ -1,3 +1,5 @@
+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'
 
 # SOL Transfer Testing Script
@@ -33,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.0beta1
+  version: 2.0.0beta2
 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