solana-ruby-web3js 2.0.0beta2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bb6650de7a5beae14649fe9cfac20973923d0be4c4f74e9d1e8f373e70842b9
-  data.tar.gz: c3ad4316d61d4326327bb281a3eb64991011ae14d51a7974de6eaf9705d4ffa5
+  metadata.gz: 9f614bab0b21438c2820d0035a0aa33567a11fedd3ecb998666b39e5ab28681d
+  data.tar.gz: c63fd671d6328732c39994032f94aff219ff77eda8cd899c5d1f0c29f86f4524
 SHA512:
-  metadata.gz: 94c8304f1d05d7cbd8ec22947d98ede21c1892b210ad5cdb43f3e6293f4c6ab288c8aa83b1ba6e40a28d08a191a32ba775966eeb370631d02112cac981309fb6
-  data.tar.gz: '0085b47b4f44786e0bd0af77827a12cbc191744a16aff61448cafff641a53efa798677ef51b3748966f76547b883fd767d3f48ffe5297f8519cc08eb1ee81e90'
+  metadata.gz: 4015bdc6179d57105ea1da82daa9d6ec19f623098d636271fb0e7ab9210d563414eae364271e58be82a2ce9ed6dc0804de53db7e7a15c5d353da4ff30faf5124
+  data.tar.gz: 8fca9ec2ccdcc5b3ea72f54fa6fad27fee3fe1aef20b145107382c523a0a70df90812f269fdcdee3d9d62b732e6ebe7ce6ad3e1514257d379db7088de55941d1

data/Gemfile.lock

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

data/README.md

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

data/lib/solana_ruby/data_types.rb

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

data/lib/solana_ruby/transaction.rb

@@ -1,5 +1,3 @@
-Dir[File.join(__dir__, 'data_types', '*.rb')].each { |file| require file }
-
 module SolanaRuby
   class Transaction
     require 'rbnacl'
@@ -72,10 +70,10 @@ module SolanaRuby
       instructions.push(item)
     end
 
-    def sign(keypairs)
-      raise 'No signers' unless keypairs.any?
+    def sign(keys)
+      raise 'No signers' unless keys.any?
 
-      keys = keypairs.uniq { |kp| kp[:public_key] }
+      keys = keys.uniq{ |k| key[:public_key] }
       @signatures = keys.map do |key|
         {
           signature: nil,
@@ -116,17 +114,15 @@ module SolanaRuby
     def compile_message
       check_for_errors
       fetch_message_data
-
-      # add instruction structure
-      instructs = add_instructs
-      
-      message_data = Message.new(
-        header: @header,
-        account_keys: @account_keys,
-        recent_blockhash: recent_blockhash,
-        instructions: instructs
+      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
       )
-     message_data
+     message
     end
 
     def check_for_errors
@@ -172,8 +168,11 @@ module SolanaRuby
       # Split out signing from non-signing keys and count header values
       signed_keys = []
       unsigned_keys = []
-      @header = split_keys(unique_metas, signed_keys, unsigned_keys)
+      header_params = 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)
@@ -246,24 +245,19 @@ 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,59 +19,46 @@ module SolanaRuby
         instruction: :uint8,
         amount: :uint64
       },
-    # Create account layout
+       # Create account layout
       create_account: {
-        instruction: :uint32,
+        instruction: :uint8,
         lamports: :uint64,
-        space: :uint64,
-        program_id: :blob32
+        space: :uint64
       }
     }
 
     # Method to create a system account (e.g., for SPL token or SOL)
-    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
+    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 },  # Funder's account
-          { pubkey: new_account_pubkey, is_signer: true, is_writable: true } # New account
+          { 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: program_id,  # Use Solana's system program for account creation
-        data: instruction_data   # Encoded instruction data
+        program_id: owner_pubkey,
+        data: instruction_data.bytes
       )
-
-      # return instruction data
       create_account_instruction
     end
 
-
-    def self.create_account(from_pubkey, new_account_pubkey, lamports, space, recent_blockhash, program_id = SYSTEM_PROGRAM_ID)
+    def self.create_and_sign_transaction(from_pubkey, new_account_pubkey, lamports, space, recent_blockhash)
       # 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
-      instruction = account_instruction(from_pubkey, new_account_pubkey, lamports, space, program_id)
-      transaction.add_instruction(instruction)
-      
-      # return the transaction for signing
+      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
       transaction
     end
 
     # Method to create a SOL transfer instruction
-    def self.transfer_sol_instruction(from_pubkey, to_pubkey, lamports)
+    def self.transfer_sol_transaction(from_pubkey, to_pubkey, lamports)
       fields = INSTRUCTION_LAYOUTS[:sol_transfer]
       data = encode_data(fields, { instruction: 2, lamports: lamports })
       TransactionInstruction.new(
@@ -85,11 +72,11 @@ module SolanaRuby
     end
 
     # Helper to create a new transaction for SOL transfer
-    def self.sol_transfer(from_pubkey, to_pubkey, lamports, recent_blockhash)
+    def self.new_sol_transaction(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_instruction(from_pubkey, to_pubkey, lamports)
+      transfer_instruction = transfer_sol_transaction(from_pubkey, to_pubkey, lamports)
       transaction.add_instruction(transfer_instruction)
       transaction
     end
@@ -120,14 +107,13 @@ module SolanaRuby
     end
 
     # Method to create an associated token account for a given token mint
-    def self.create_associated_token_account(payer, mint, owner)
+    def self.create_associated_token_account(from_pubkey, token_mint, owner_pubkey)
       data = [0, 0, 0, 0]  # No data required for account creation
       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: 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 }
         ],

data/lib/solana_ruby/version.rb

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

data/transaction_testing/create_account.rb

@@ -3,55 +3,30 @@
 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 }
 
-# Initialize Solana client
+# Testing Script
+
 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}"
 
-# Sender keypair and public key
-private_key = "d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778"
-sender_keypair = SolanaRuby::Keypair.from_private_key(private_key)
+# Generate a sender keypair and public key
+sender_keypair = SolanaRuby::Keypair.from_private_key("d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778")
 sender_pubkey = sender_keypair[:public_key]
-puts "Sender Public Key: #{sender_pubkey}"
-
-# Check sender's account balance
+lamports = 1 * 1_000_000_000
+space = 165
 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
+puts "sender account balance: #{balance}, wait for few seconds to update the balance in solana when the balance 0"
+
 
-# new keypair and public key (new account)
+# Generate a receiver keypair and public key
 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' })
 
-# Output transaction results
-puts "Transaction Signature: #{response}"
-puts "New account created successfully with Public Key: #{new_account_pubkey}"
+# create a transaction instruction
+transaction = SolanaRuby::TransactionHelper.create_and_sign_transaction(sender_pubkey, new_account_pubkey, lamports, space, recent_blockhash)
 
+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.sol_transfer(
+transaction = SolanaRuby::TransactionHelper.new_sol_transaction(
   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.0beta2
+  version: 2.0.0
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-28 00:00:00.000000000 Z
+date: 2024-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple