solana-ruby-web3js 1.0.1.beta3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 769dd8aff42953255243d337b811ab9bd61e27e19e6957d235e9e015300f925b
-  data.tar.gz: e940aa048c15af34c5f06bf5de1db3716e8f68f1f83c41fe480a6de748082310
+  metadata.gz: 9f614bab0b21438c2820d0035a0aa33567a11fedd3ecb998666b39e5ab28681d
+  data.tar.gz: c63fd671d6328732c39994032f94aff219ff77eda8cd899c5d1f0c29f86f4524
 SHA512:
-  metadata.gz: 7cd8eb6a1ff5a1c749cb1ded759323bd1a7a43dea78e6d19444f1d1e8dc77ca24f757c5fc53412431020f09960db0cef8f2bd519641a0bdc5790c4dc8e60a581
-  data.tar.gz: d6c68d6c97ae798d5b79b4fcaae962ac3e34e7e2d28d61b80124b4725b3926803c49f20bd055bc7c6af9b46229558111a3ea0dae932d15750f726484a0c6b460
+  metadata.gz: 4015bdc6179d57105ea1da82daa9d6ec19f623098d636271fb0e7ab9210d563414eae364271e58be82a2ce9ed6dc0804de53db7e7a15c5d353da4ff30faf5124
+  data.tar.gz: 8fca9ec2ccdcc5b3ea72f54fa6fad27fee3fe1aef20b145107382c523a0a70df90812f269fdcdee3d9d62b732e6ebe7ce6ad3e1514257d379db7088de55941d1

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/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,281 @@
+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.0"
 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,56 @@
+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
+
+# 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.0
 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