solana-ruby-web3js 1.0.1.beta3 → 2.0.0beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 769dd8aff42953255243d337b811ab9bd61e27e19e6957d235e9e015300f925b
-  data.tar.gz: e940aa048c15af34c5f06bf5de1db3716e8f68f1f83c41fe480a6de748082310
+  metadata.gz: 37360e6f27ca521194022c29c3419d2dc06e5dcae0499af04892e3ca29299b0d
+  data.tar.gz: c5748b0ddacfaa170e79aba9a16b883c64a05ac7f776f0589c3914a5ad418356
 SHA512:
-  metadata.gz: 7cd8eb6a1ff5a1c749cb1ded759323bd1a7a43dea78e6d19444f1d1e8dc77ca24f757c5fc53412431020f09960db0cef8f2bd519641a0bdc5790c4dc8e60a581
-  data.tar.gz: d6c68d6c97ae798d5b79b4fcaae962ac3e34e7e2d28d61b80124b4725b3926803c49f20bd055bc7c6af9b46229558111a3ea0dae932d15750f726484a0c6b460
+  metadata.gz: 683573ae5898ae932dea765b65cc4d73136f198429920be4e923da76bfed3b515e941f96761238f42dd92cedadc7d28c03f43dc3357fb07451a4940b3a2e93e0
+  data.tar.gz: e6c3b0e84760561c6b22290f3dab047cb041f9de7ed02d1a7cd88cc5ed285a6fb5c2ca97e7a719f709044c044b3c769aa0d0c612bb35b5894e0e70f1955e9c4e

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    solana-ruby-web3js (1.0.1.beta1)
+    solana-ruby-web3js (1.0.1.beta3)
       base58 (~> 0.2.3)
       base64 (~> 0.2.0)
+      ed25519
+      rbnacl (~> 6.0)
       websocket-client-simple (~> 0.8.0)
 
 GEM
@@ -64,6 +66,8 @@ GEM
     ed25519 (1.3.0)
     erubi (1.13.0)
     event_emitter (0.2.6)
+    ffi (1.17.0)
+    ffi (1.17.0-arm64-darwin)
     flay (2.13.3)
       erubi (~> 1.10)
       path_expander (~> 1.0)
@@ -93,6 +97,8 @@ GEM
     public_suffix (6.0.1)
     racc (1.8.1)
     rainbow (3.1.1)
+    rbnacl (6.0.1)
+      ffi
     reek (6.3.0)
       dry-schema (~> 1.13.0)
       parser (~> 3.3.0)

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 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
+    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 # generate receiver keypair
+    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.new_sol_transaction(
+      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/blob.rb

@@ -0,0 +1,30 @@
+module SolanaRuby
+  module DataTypes
+    class Blob
+      attr_reader :size
+
+      # Constructor to initialize size of the blob
+      def initialize(size)
+        raise ArgumentError, "Size must be a positive integer" unless size.is_a?(Integer) && size > 0
+        @size = size
+      end
+
+      # Serialize the given object to a byte array
+      def serialize(obj)
+        # Ensure obj is an array and then convert to byte array
+        obj = [obj] unless obj.is_a?(Array)
+        raise ArgumentError, "Object must be an array of bytes" unless obj.all? { |e| e.is_a?(Integer) && e.between?(0, 255) }
+
+        obj.pack('C*').bytes
+      end
+
+      # Deserialize a byte array into the original object format
+      def deserialize(bytes)
+        # Ensure the byte array is of the correct size
+        raise ArgumentError, "Byte array size must match the expected size" unless bytes.length == @size
+
+        bytes.pack('C*')
+      end
+    end
+  end
+end

data/lib/solana_ruby/data_types/layout.rb

@@ -0,0 +1,27 @@
+module SolanaRuby
+  module DataTypes
+    class Layout
+      attr_reader :fields
+
+      def initialize(fields)
+        @fields = fields
+      end
+
+      def serialize(params)
+        fields.flat_map do |field, type|
+          data_type = type.is_a?(Symbol) ? SolanaRuby::DataTypes.send(type) : type
+          data_type.serialize(params[field])
+        end
+      end
+
+      def deserialize(bytes)
+        result = {}
+        fields.map do |field, type|
+          data_type = type.is_a?(Symbol) ? SolanaRuby::DataTypes.send(type) : type
+          result[field] = data_type.deserialize(bytes.shift(data_type.size))
+        end
+        result
+      end
+    end
+  end
+end

data/lib/solana_ruby/data_types/near_int64.rb

@@ -0,0 +1,40 @@
+module SolanaRuby
+  module DataTypes
+    class NearInt64
+      attr_reader :size
+
+      V2E32 = 2.pow(32)
+
+      def initialize
+        @size = 8
+      end
+
+      def serialize(obj)
+        uint = UnsignedInt.new(32)
+        numbers = divmod_int64(obj)
+        numbers.map{|x| uint.serialize(x)}.flatten
+      end
+
+      def deserialize(bytes)
+        raise "Invalid serialization (wrong size)" if @size && bytes.size != @size
+        uint = UnsignedInt.new(32)
+        half_size = @size/2
+
+        lo, hi = [bytes[0..half_size-1], bytes[half_size..-1]].map{|x| uint.deserialize(x)}
+
+        rounded_int64(hi, lo)
+      end
+
+      def divmod_int64(obj)
+        obj = obj * 1.0
+        hi32 = (obj / V2E32).floor
+        lo32 = (obj - (hi32 * V2E32)).floor
+        [lo32, hi32]
+      end
+
+      def rounded_int64(hi32, lo32)
+        hi32 * V2E32 + lo32
+      end
+    end
+  end
+end

data/lib/solana_ruby/data_types/sequence.rb

@@ -0,0 +1,23 @@
+module SolanaRuby
+  module DataTypes
+    class Sequence
+      def initialize count, type
+        @count = count
+        @type = type
+      end
+
+      def serialize items
+        items.map do |item|
+          @type.serialize(item)
+        end.flatten
+      end
+
+      def deserialize bytes
+        @count.times.map do
+          current_bytes = bytes.shift(@type.size)
+          @type.deserialize(current_bytes)
+        end
+      end
+    end
+  end
+end

data/lib/solana_ruby/data_types/unsigned_int.rb

@@ -0,0 +1,40 @@
+module SolanaRuby
+  module DataTypes
+    class UnsignedInt
+      attr_reader :size
+
+      BITS = {
+        8 => { directive: 'C*', size: 1 },
+        32 => { directive: 'L*', size: 4 },
+        64 => { directive: 'Q*', size: 8 }
+      }
+
+      def initialize(bits)
+        @bits = bits
+        type = BITS[@bits]
+        raise "Can only fit #{BITS.keys}" unless type
+        @size = type[:size]
+        @directive = type[:directive]
+      end
+
+      # 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 < 0
+
+        if obj >= 256**@size
+          raise "Integer too large (does not fit in #{@size} bytes)"
+        end
+
+        [obj].pack(@directive).bytes
+      end
+
+      # Deserialize bytes into the unsigned integer
+      def deserialize(bytes)
+        raise "Invalid serialization (wrong size)" if bytes.size != @size
+
+        bytes.pack('C*').unpack(@directive).first
+      end
+    end
+  end
+end

data/lib/solana_ruby/data_types.rb

@@ -0,0 +1,25 @@
+module SolanaRuby
+  module DataTypes
+    extend self
+
+    def uint8
+      UnsignedInt.new(8)
+    end
+
+    def uint32
+      UnsignedInt.new(32)
+    end
+
+    def uint64
+      UnsignedInt.new(64)
+    end
+
+    def near_int64
+      NearInt64.new
+    end
+
+    def blob1
+      Blob.new(1)
+    end
+  end
+end

data/lib/solana_ruby/http_client.rb

@@ -23,7 +23,8 @@ module SolanaRuby
 
     def request(method, params = [])
       http = Net::HTTP.new(@uri.host, @uri.port)
-      http.use_ssl = true
+      local_hosts = ['localhost', '127.0.0.1', '[::1]']
+      http.use_ssl = true unless local_hosts.include?(@uri.host.downcase)
 
       request = Net::HTTP::Post.new(@uri.request_uri, {'Content-Type' => 'application/json'})
       request.body = {

data/lib/solana_ruby/keypair.rb

@@ -0,0 +1,42 @@
+module SolanaRuby
+  class Keypair
+    require 'rbnacl'
+    require 'base58'
+
+    # 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)
+      }
+    end
+
+    # Restores a keypair from a private key in hex format
+    def self.from_private_key(private_key_hex)
+      raise ArgumentError, "Invalid private key length" unless private_key_hex.size == 64
+
+      # Convert hex private key to binary format for signing key
+      private_key_bytes = [private_key_hex].pack('H*')
+
+      # Initialize signing key
+      signing_key = RbNaCl::Signatures::Ed25519::SigningKey.new(private_key_bytes)
+
+      # Extract public key in binary format
+      public_key_bytes = signing_key.verify_key.to_bytes
+
+      # Return public key in Base58 format and private key in hex format
+      {
+        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)
+      }
+    end
+  end
+end

data/lib/solana_ruby/message.rb

@@ -0,0 +1,107 @@
+module SolanaRuby
+  class Message
+    PUBKEY_LENGTH = 32
+
+    attr_reader :header, :account_keys, :recent_blockhash, :instructions
+
+    def initialize(header:, account_keys:, recent_blockhash:, instructions:)
+      @header = header
+      @account_keys = account_keys
+      @recent_blockhash = recent_blockhash
+      @instructions = instructions
+    end
+
+    def self.from(bytes)
+      bytes = bytes.dup
+      num_required_signatures = bytes.shift
+      num_readonly_signed_accounts = bytes.shift
+      num_readonly_unsigned_accounts = bytes.shift
+      account_count = Utils.decode_length(bytes)
+
+      account_keys = account_count.times.map do
+        account_bytes = bytes.slice!(0, PUBKEY_LENGTH)
+        Utils.bytes_to_base58(account_bytes)
+      end
+
+      recent_blockhash_bytes = bytes.slice!(0, PUBKEY_LENGTH)
+      recent_blockhash = Utils.bytes_to_base58(recent_blockhash_bytes)
+
+      instruction_count = Utils.decode_length(bytes)
+      instructions = instruction_count.times.map do
+        program_id_index = bytes.shift
+        account_count = Utils.decode_length(bytes)
+
+        accounts = bytes.slice!(0, account_count)
+
+        data_length = Utils.decode_length(bytes)
+        data_bytes = bytes.slice!(0, data_length)
+        {program_id_index: program_id_index, accounts: accounts, data: data_bytes}
+      end
+      self.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: instructions
+      })
+    end
+
+    def serialize
+      num_keys = account_keys.length
+      key_count = Utils.encode_length(num_keys)
+
+      layout = SolanaRuby::DataTypes::Layout.new({
+        num_required_signatures: :blob1,
+        num_readonly_signed_accounts: :blob1,
+        num_readonly_unsigned_accounts: :blob1,
+        key_count: SolanaRuby::DataTypes::Blob.new(key_count.length),
+        keys: SolanaRuby::DataTypes::Sequence.new(num_keys, SolanaRuby::DataTypes::Blob.new(32)),
+        recent_blockhash: SolanaRuby::DataTypes::Blob.new(32)
+      })
+
+      sign_data = layout.serialize({
+        num_required_signatures: header[:num_required_signatures],
+        num_readonly_signed_accounts: header[:num_readonly_signed_accounts],
+        num_readonly_unsigned_accounts: header[:num_readonly_unsigned_accounts],
+        key_count: key_count,
+        keys: account_keys.map{|x| Utils.base58_to_bytes(x)},
+        recent_blockhash: Utils.base58_to_bytes(recent_blockhash)
+      })
+
+      instruction_count = Utils.encode_length(@instructions.length)
+      sign_data += instruction_count
+
+      data = @instructions.map do |instruction|
+        instruction_layout = SolanaRuby::DataTypes::Layout.new({
+          program_id_index: :uint8,
+          key_indices_count: SolanaRuby::DataTypes::Blob.new(key_count.length),
+          key_indices: SolanaRuby::DataTypes::Sequence.new(num_keys, SolanaRuby::DataTypes::Blob.new(8)),
+          data_length: SolanaRuby::DataTypes::Blob.new(key_count.length),
+          data: SolanaRuby::DataTypes::Sequence.new(num_keys, SolanaRuby::DataTypes::UnsignedInt.new(8)),
+        })
+
+        key_indices_count = Utils.encode_length(instruction[:accounts].length)
+        data_count = Utils.encode_length(instruction[:data].length)
+
+        instruction_layout.serialize({
+          program_id_index: instruction[:program_id_index],
+          key_indices_count: key_indices_count,
+          key_indices: instruction[:accounts],
+          data_length: data_count,
+          data: instruction[:data]
+        })
+      end.flatten
+
+      sign_data += data
+      sign_data
+    end
+
+    def is_account_writable(index)
+      index < header[:num_required_signatures] - header[:num_readonly_signed_accounts] ||
+      (index >= header[:num_required_signatures] && index <  account_keys.length - header[:num_readonly_unsigned_accounts])
+    end
+  end
+end

data/lib/solana_ruby/transaction.rb

@@ -0,0 +1,283 @@
+Dir[File.join(__dir__, 'data_types', '*.rb')].each { |file| require file }
+
+module SolanaRuby
+  class Transaction
+    require 'rbnacl'
+    SIGNATURE_LENGTH = 64
+    PACKET_DATA_SIZE = 1280 - 40 - 8
+    DEFAULT_SIGNATURE = Array.new(64, 0)
+
+    attr_accessor :instructions, :signatures, :fee_payer, :recent_blockhash, :message
+
+    def initialize(recent_blockhash: nil, signatures: [], instructions: [], fee_payer: nil)
+      @recent_blockhash = recent_blockhash
+      @signatures = signatures
+      @instructions = instructions
+      @fee_payer = fee_payer
+    end
+
+    def add_instruction(instruction)
+      @instructions << instruction
+    end
+
+    def set_fee_payer(pubkey)
+      puts "Setting fee payer: #{pubkey.inspect}"  # Debugging output
+      @fee_payer = pubkey  # Store as-is since Base58 gem can handle encoding/decoding
+    end
+
+    def set_recent_blockhash(blockhash)
+      # raise "Invalid Base58 blockhash" unless Base58.valid?(blockhash)
+      @recent_blockhash = blockhash  # Store as-is for similar reasons
+    end
+
+    def self.from(base64_string)
+      bytes = Base64.decode64(base64_string).bytes
+      signature_count = Utils.decode_length(bytes)
+      signatures = signature_count.times.map do
+        signature_bytes = bytes.slice!(0, SIGNATURE_LENGTH)
+        Utils.bytes_to_base58(signature_bytes)
+      end
+      msg = Message.from(bytes)
+      self.populate(msg, signatures)
+    end
+
+    def serialize
+      sign_data = serialize_message
+
+      signature_count = Utils.encode_length(signatures.length)
+      raise 'invalid length!' if signatures.length > 256
+      
+      wire_transaction = signature_count
+
+      signatures.each do |signature|
+        if signature
+          signature_bytes = signature[:signature]
+          raise 'signature is empty' unless (signature_bytes)
+          raise 'signature has invalid length' unless (signature_bytes.length == 64)
+          wire_transaction += signature_bytes
+          raise "Transaction too large: #{wire_transaction.length} > #{PACKET_DATA_SIZE}" unless wire_transaction.length <= PACKET_DATA_SIZE
+          wire_transaction
+        end
+      end
+
+      wire_transaction += sign_data
+      wire_transaction
+    end
+
+    def to_base64
+      Base64.strict_encode64(serialize.pack('C*'))
+    end
+
+    def add(item)
+      instructions.push(item)
+    end
+
+    def sign(keys)
+      raise 'No signers' unless keys.any?
+
+      keys = keys.uniq{ |k| key[:public_key] }
+      @signatures = keys.map do |key|
+        {
+          signature: nil,
+          public_key: key[:public_key]
+        }
+      end
+
+      message = compile_message
+      partial_sign(message, keys)
+      true
+    end
+
+    private
+
+    def serialize_message
+      compile.serialize
+    end
+
+    def compile
+      message = compile_message
+      signed_keys = message.account_keys.slice(0, message.header[:num_required_signatures])
+
+      if signatures.length == signed_keys.length
+        valid = signatures.each_with_index.all?{|pair, i| signed_keys[i] == pair[:public_key]}
+        return message if valid
+      end
+
+      @signatures = signed_keys.map do |public_key|
+        {
+          signature: nil,
+          public_key: public_key
+        }
+      end
+
+      message
+    end
+
+    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
+      )
+     message
+    end
+
+    def check_for_errors
+      raise 'Transaction recent_blockhash required' unless recent_blockhash
+
+      puts 'No instructions provided' if instructions.length < 1
+
+      if fee_payer.nil? && signatures.length > 0 && signatures[0][:public_key]
+        @fee_payer = signatures[0][:public_key] if (signatures.length > 0 && signatures[0][:public_key])
+      end
+      
+      raise('Transaction fee payer required') if @fee_payer.nil?
+
+      instructions.each_with_index do |instruction, i|
+        raise("Transaction instruction index #{i} has undefined program id") unless instruction.program_id
+      end
+    end
+
+    def fetch_message_data
+      program_ids = []
+      account_metas= []
+
+      instructions.each do |instruction|
+        account_metas += instruction.keys
+        program_ids.push(instruction.program_id) unless program_ids.include?(instruction.program_id)
+      end
+
+      # Append programID account metas
+      append_program_id(program_ids, account_metas)
+
+      # Sort. Prioritizing first by signer, then by writable
+      signer_order(account_metas)
+
+      # Cull duplicate account metas
+      unique_metas = []
+      add_unique_meta_data(unique_metas, account_metas)
+
+      add_fee_payer_meta(unique_metas)
+
+      # Disallow unknown signers
+      disallow_signers(signatures, unique_metas)
+
+      # 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)
+      @account_keys = signed_keys + unsigned_keys
+      
+      # add instruction structure
+      @instructs = add_instructs
+    end
+
+    def append_program_id(program_ids, account_metas)
+      program_ids.each do |programId|
+        account_metas.push({
+                            pubkey: programId,
+                            is_signer: false,
+                            is_writable: false,
+                          })
+      end
+    end
+
+    def signer_order(account_metas)
+      account_metas.sort! do |x, y|
+        check_signer = x[:is_signer] == y[:is_signer] ? nil : x[:is_signer] ? -1 : 1
+        check_writable = x[:is_writable] == y[:is_writable] ? nil : (x[:is_writable] ? -1 : 1)
+        (check_signer || check_writable) || 0
+      end
+    end
+
+    def add_unique_meta_data(unique_metas, account_metas)
+      account_metas.each do |account_meta|
+        pubkey_string = account_meta[:pubkey]
+        unique_index = unique_metas.find_index{|x| x[:pubkey] == pubkey_string }
+        if unique_index
+          unique_metas[unique_index][:is_writable] = unique_metas[unique_index][:is_writable] || account_meta[:is_writable]
+        else
+          unique_metas.push(account_meta);
+        end
+      end
+    end
+
+    def add_fee_payer_meta(unique_metas)
+      # Move fee payer to the front
+      fee_payer_index = unique_metas.find_index { |x| x[:pubkey] == fee_payer }
+      if fee_payer_index
+        payer_meta = unique_metas.delete_at(fee_payer_index)
+        payer_meta[:is_signer] = true
+        payer_meta[:is_writable] = true
+        unique_metas.unshift(payer_meta)
+      else
+        unique_metas.unshift({
+                              pubkey: fee_payer,
+                              is_signer: true,
+                              is_writable: true,
+                            })
+      end
+    end
+
+    def disallow_signers(signatures, unique_metas)
+      signatures.each do |signature|
+        unique_index = unique_metas.find_index{ |x| x[:pubkey] == signature[:public_key] }
+
+        if unique_index
+          unique_metas[unique_index][:is_signer] = true unless unique_metas[unique_index][:is_signer]
+        else
+          raise "unknown signer: #{signature[:public_key]}"
+        end
+      end
+    end
+
+    def add_instructs
+      instructions.map do |instruction|
+        {
+          program_id_index: @account_keys.index(instruction.program_id),
+          accounts: instruction.keys.map { |meta| @account_keys.index(meta[:pubkey]) },
+          data: instruction.data
+        }
+      end
+    end
+
+    def split_keys(unique_metas, signed_keys, unsigned_keys)
+      @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])
+        else
+          unsigned_keys.push(meta[:pubkey])
+          @num_readonly_unsigned_accounts += 1 if (!meta[:is_writable])
+        end
+      end
+    end
+
+    def partial_sign(message, keys)
+      sign_data = message.serialize
+      keys.each do |key|
+        private_key_bytes = [key[:private_key]].pack('H*')
+        signing_key = RbNaCl::Signatures::Ed25519::SigningKey.new(private_key_bytes)
+        signature = signing_key.sign(sign_data.pack('C*')).bytes
+        add_signature(key[:public_key], signature)
+      end
+    end
+
+    def add_signature(pubkey,  signature)
+      raise 'error' unless signature.length === 64
+      index = signatures.find_index{|s| s[:public_key] == pubkey}
+      raise "unknown signer: #{pubkey}" unless index
+
+      @signatures[index][:signature] = signature
+    end
+  end
+end

data/lib/solana_ruby/transaction_helper.rb

@@ -0,0 +1,138 @@
+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'
+
+    INSTRUCTION_LAYOUTS = {
+      # Native SOL transfer
+      sol_transfer: {
+        instruction: :uint32,
+        lamports: :near_int64
+      },
+      # SPL token transfer
+      spl_transfer: {
+        instruction: :uint8,
+        amount: :uint64
+      },
+       # Create account layout
+      create_account: {
+        instruction: :uint8,
+        lamports: :uint64,
+        space: :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
+      )
+      create_account_instruction
+    end
+
+    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
+      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_transaction(from_pubkey, to_pubkey, lamports)
+      fields = INSTRUCTION_LAYOUTS[:sol_transfer]
+      data = encode_data(fields, { instruction: 2, lamports: lamports })
+      TransactionInstruction.new(
+        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
+      )
+    end
+
+    # Helper to create a new transaction for SOL transfer
+    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_transaction(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
+      )
+    end
+
+    # Helper to create a new transaction for SPL token transfer
+    def self.new_spl_token_transaction(source, destination, owner, amount, recent_blockhash)
+      transaction = Transaction.new
+      transaction.set_fee_payer(owner)
+      transaction.set_recent_blockhash(recent_blockhash)
+      transfer_instruction = transfer_spl_token(source, destination, owner, amount)
+      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
+      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 }
+        ],
+        program_id: ASSOCIATED_TOKEN_PROGRAM_ID,
+        data: data
+      )
+      create_account_instruction
+    end
+
+    # Utility to encode data using predefined layouts
+    def self.encode_data(fields, data)
+      layout = SolanaRuby::DataTypes::Layout.new(fields)
+      layout.serialize(data)
+    end
+
+    # Utility to decode data using predefined layouts
+    def self.decode_data(fields, data)
+      layout = SolanaRuby::DataTypes::Layout.new(fields)
+      layout.deserialize(data)
+    end
+  end
+end

data/lib/solana_ruby/transaction_instruction.rb

@@ -0,0 +1,42 @@
+module SolanaRuby
+  class TransactionInstruction
+    require 'base58'
+
+    attr_accessor :keys, :program_id, :data
+
+    def initialize(keys:, program_id:, data:)
+      @keys = keys           # Array of account metadata hashes
+      @program_id = program_id  # Program ID in Base58
+      @data = data           # Binary data for the instruction
+    end
+
+    def serialize
+      serialized_instruction = ""
+
+      # Convert and serialize the program ID from Base58 to binary
+      program_id_binary = Base58.base58_to_binary(@program_id)
+      serialized_instruction << program_id_binary
+
+      # Serialize the number of keys
+      serialized_instruction << [@keys.length].pack("C")
+
+      # Serialize each key (pubkey in binary, is_signer, is_writable flags)
+      @keys.each do |key_meta|
+        # Convert public key to binary and serialize it
+        pubkey_binary = Base58.base58_to_binary(key_meta[:pubkey])
+        serialized_instruction << pubkey_binary
+
+        # Serialize meta flags (is_signer and is_writable)
+        meta_flags = (key_meta[:is_signer] ? 1 : 0) | (key_meta[:is_writable] ? 2 : 0)
+        serialized_instruction << [meta_flags].pack("C")
+      end
+
+      # Serialize data length (encoded as a single byte, can adjust with C, S, and L accordingly if data is larger)
+      serialized_instruction << [@data.length].pack("C")
+
+      # Serialize the actual data in binary format
+      serialized_instruction << @data
+      serialized_instruction
+    end
+  end
+end

data/lib/solana_ruby/utils.rb

@@ -0,0 +1,66 @@
+require 'base58'
+require 'digest/sha2'
+
+module SolanaRuby
+  class Utils
+    class << self
+      # Decodes a length-prefixed byte array using a variable-length encoding.
+      def decode_length(bytes)
+        raise ArgumentError, "Input must be an array of bytes" unless bytes.is_a?(Array)
+
+        length = 0
+        size = 0
+        loop do
+          raise "Unexpected end of bytes during length decoding" if bytes.empty?
+
+          byte = bytes.shift
+          length |= (byte & 0x7F) << (size * 7)
+          size += 1
+          break if (byte & 0x80).zero?
+        end
+        length
+      end
+
+      # Encodes a length as a variable-length byte array.
+      def encode_length(length)
+        raise ArgumentError, "Length must be a non-negative integer" unless length.is_a?(Integer) && length >= 0
+
+        bytes = []
+        loop do
+          byte = length & 0x7F
+          length >>= 7
+          if length.zero?
+            bytes << byte
+            break
+          else
+            bytes << (byte | 0x80)
+          end
+        end
+        bytes
+      end
+
+      # Converts a byte array to a Base58-encoded string.
+      def bytes_to_base58(bytes)
+        raise ArgumentError, "Input must be an array of bytes" unless bytes.is_a?(Array)
+        
+        Base58.binary_to_base58(bytes.pack('C*'), :bitcoin)
+      end
+
+      # Converts a Base58-encoded string to a byte array.
+      def base58_to_bytes(base58_string)
+        raise ArgumentError, "Input must be a non-empty string" unless base58_string.is_a?(String) && !base58_string.empty?
+
+        Base58.base58_to_binary(base58_string, :bitcoin).bytes
+      rescue ArgumentError
+        raise "Invalid Base58 string: #{base58_string}"
+      end
+
+      # Computes the SHA-256 hash of the given data and returns it as a hexadecimal string.
+      def sha256(data)
+        raise ArgumentError, "Data must be a string" unless data.is_a?(String)
+
+        Digest::SHA256.hexdigest(data)
+      end
+    end
+  end
+end

data/lib/solana_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolanaRuby
-  VERSION = "1.0.1.beta3"
+  VERSION = "2.0.0beta1"
 end

data/lib/solana_ruby.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "solana_ruby/version"
-require_relative "solana_ruby/http_client"
-require_relative "solana_ruby/web_socket_client"
+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/create_account.rb

@@ -0,0 +1,32 @@
+# 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 }
+
+# Testing Script
+
+client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
+
+# Fetch the recent blockhash
+recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+# Generate a sender keypair and public key
+sender_keypair = SolanaRuby::Keypair.from_private_key("d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778")
+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"
+
+
+# Generate a receiver keypair and public key
+new_account = SolanaRuby::Keypair.generate
+new_account_pubkey = new_account[:public_key]
+
+# 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

@@ -0,0 +1,54 @@
+require 'pry'
+
+# 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"]
+
+# Generate a sender keypair and public key or Fetch payers keypair using private key
+# sender_keypair = SolanaRuby::Keypair.from_private_key("InsertPrivateKeyHere")
+sender_keypair = SolanaRuby::Keypair.generate
+sender_pubkey = sender_keypair[:public_key]
+
+
+# Airdrop some lamports to the sender's account
+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 existing receiver keypair and public key
+keypair = SolanaRuby::Keypair.generate # generate receiver keypair
+receiver_pubkey = keypair[: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: #{keypair[:full_private_key]}"
+puts "Receiver's Public Key: #{keypair[:public_key]}"
+
+# Create a new transaction
+transaction = SolanaRuby::TransactionHelper.new_sol_transaction(
+  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/transaction_testing/spl_token_transfer.rb

@@ -0,0 +1,55 @@
+# 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 }
+# Dir["solana_ruby/*.rb"].each { |f| require_relative f.delete(".rb") }
+
+
+# Testing Script
+
+client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
+
+# Fetch the recent blockhash
+recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+# Generate a sender keypair and public key
+fee_payer = SolanaRuby::Keypair.from_private_key("d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778")
+fee_payer_pubkey = fee_payer[:public_key]
+lamports = 10 * 1_000_000_000
+space = 165
+
+# get balance for the fee payer
+balance = client.get_balance(fee_payer_pubkey)
+puts "sender account balance: #{balance}, wait for few seconds to update the balance in solana when the balance 0"
+
+
+# # Generate a receiver keypair and public key
+keypair = SolanaRuby::Keypair.generate
+receiver_pubkey = keypair[:public_key]
+transfer_lamports = 1 * 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'
+token_program_id = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+
+# Create a new transaction
+transaction = SolanaRuby::TransactionHelper.new_spl_token_transaction(
+  "9BvJGQC5FkLJzUC2TmYpi1iU8n9vt2388GLT5zvu8S1G",
+  receiver_pubkey,
+  fee_payer_pubkey,
+  transfer_lamports,
+  recent_blockhash
+)
+# # Get the sender's private key (ensure it's a string)
+private_key = fee_payer[:private_key]
+puts "Private key type: #{private_key.class}, Value: #{private_key.inspect}"
+
+# Sign the transaction
+signed_transaction = transaction.sign([fee_payer])
+
+# Send the transaction to the Solana network
+sleep(5)
+response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+puts "Response: #{response}"
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-web3js
 version: !ruby/object:Gem::Version
-  version: 1.0.1.beta3
+  version: 2.0.0beta1
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-03 00:00:00.000000000 Z
+date: 2024-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: rbnacl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: brakeman
   requirement: !ruby/object:Gem::Requirement
@@ -201,6 +229,12 @@ files:
 - lib/solana_ruby.rb
 - lib/solana_ruby/.DS_Store
 - lib/solana_ruby/base_client.rb
+- lib/solana_ruby/data_types.rb
+- lib/solana_ruby/data_types/blob.rb
+- lib/solana_ruby/data_types/layout.rb
+- 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/http_client.rb
 - lib/solana_ruby/http_methods/account_methods.rb
 - lib/solana_ruby/http_methods/basic_methods.rb
@@ -211,6 +245,12 @@ files:
 - lib/solana_ruby/http_methods/slot_methods.rb
 - lib/solana_ruby/http_methods/token_methods.rb
 - lib/solana_ruby/http_methods/transaction_methods.rb
+- lib/solana_ruby/keypair.rb
+- lib/solana_ruby/message.rb
+- lib/solana_ruby/transaction.rb
+- lib/solana_ruby/transaction_helper.rb
+- lib/solana_ruby/transaction_instruction.rb
+- lib/solana_ruby/utils.rb
 - lib/solana_ruby/version.rb
 - lib/solana_ruby/web_socket_client.rb
 - lib/solana_ruby/web_socket_handlers.rb
@@ -219,6 +259,9 @@ 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/create_account.rb
+- transaction_testing/sol_transfer.rb
+- transaction_testing/spl_token_transfer.rb
 homepage: https://github.com/Build-Squad/solana-ruby
 licenses:
 - MIT
@@ -241,7 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: Solana Ruby SDK