solana-ruby-web3js 1.0.1.beta4 → 2.0.0beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ca6cbe9f7024efc46fc77b926caa77368c337d69f12b2d5bde3434cacd8be99
-  data.tar.gz: 7e4823b24785b3ec0d54f96f2a9b43b02cbdbedfe4732bf674249918b08beeab
+  metadata.gz: 37360e6f27ca521194022c29c3419d2dc06e5dcae0499af04892e3ca29299b0d
+  data.tar.gz: c5748b0ddacfaa170e79aba9a16b883c64a05ac7f776f0589c3914a5ad418356
 SHA512:
-  metadata.gz: 1d75c69661f9bd7353c9251d8cb7615785d5233d7832a1e596c02997a42b1f07dbfb9600abb45ea2b04dfc8d80ddbe2167e91e2504c436ca27e99ec30a4679f2
-  data.tar.gz: e4784c227e3e24fd2bcaf79734b42602540c39c8ed4338fc5a53d740b2077aedeb76e7bb62c84d7cf4bc54c5a044281293d02adfd92fc487483d428ab03c1ea5
+  metadata.gz: 683573ae5898ae932dea765b65cc4d73136f198429920be4e923da76bfed3b515e941f96761238f42dd92cedadc7d28c03f43dc3357fb07451a4940b3a2e93e0
+  data.tar.gz: e6c3b0e84760561c6b22290f3dab047cb041f9de7ed02d1a7cd88cc5ed285a6fb5c2ca97e7a719f709044c044b3c769aa0d0c612bb35b5894e0e70f1955e9c4e

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

@@ -7,12 +7,14 @@ module SolanaRuby
     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_hex = signing_key.to_bytes.unpack1('H*') # Hex format for private 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),
-        private_key: private_key_hex
+        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
 
@@ -31,8 +33,9 @@ module SolanaRuby
 
       # Return public key in Base58 format and private key in hex format
       {
-        public_key: Base58.binary_to_base58(public_key_bytes),
-        private_key: private_key_hex
+        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

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

@@ -1,14 +1,19 @@
+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
+    attr_accessor :instructions, :signatures, :fee_payer, :recent_blockhash, :message
 
-    def initialize
-      @instructions = []
-      @signatures = []
-      @fee_payer = nil
-      @recent_blockhash = nil
+    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)
@@ -17,92 +22,262 @@ module SolanaRuby
 
     def set_fee_payer(pubkey)
       puts "Setting fee payer: #{pubkey.inspect}"  # Debugging output
-      unless Base58.valid?(pubkey)
-        raise "Invalid Base58 public key for fee payer: #{pubkey.inspect}"
-      end
       @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)
+      # 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
-      raise "Recent blockhash not set" if @recent_blockhash.nil?
-      raise "Fee payer not set" if @fee_payer.nil?
+      sign_data = serialize_message
 
-      transaction_data = []
-      transaction_data << Base58.base58_to_binary(@recent_blockhash)  # Convert as needed here
-      transaction_data << Base58.base58_to_binary(@fee_payer)
-      transaction_data << [@instructions.length].pack("C")
+      signature_count = Utils.encode_length(signatures.length)
+      raise 'invalid length!' if signatures.length > 256
+      
+      wire_transaction = signature_count
 
-      @instructions.each do |instruction|
-        serialized_instruction = instruction.serialize
-        raise "Instruction serialization failed" if serialized_instruction.nil?
-        transaction_data << serialized_instruction
+      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
 
-      serialized = transaction_data.join
-      puts "Serialized Transaction Data: #{serialized.bytes.inspect}"  # Debugging output
+      wire_transaction += sign_data
+      wire_transaction
+    end
+
+    def to_base64
+      Base64.strict_encode64(serialize.pack('C*'))
+    end
 
-      serialized
+    def add(item)
+      instructions.push(item)
     end
 
-    def sign(private_key_hex)
-      private_key_bytes = [private_key_hex].pack('H*')
-      signing_key = RbNaCl::Signatures::Ed25519::SigningKey.new(private_key_bytes)
+    def sign(keys)
+      raise 'No signers' unless keys.any?
 
-      message = serialize_message
-      signature = signing_key.sign(message)
+      keys = keys.uniq{ |k| key[:public_key] }
+      @signatures = keys.map do |key|
+        {
+          signature: nil,
+          public_key: key[:public_key]
+        }
+      end
 
-      @signatures << signature  # Store as binary
-      Base58.binary_to_base58(signature)  # Convert to Base58 for external use
+      message = compile_message
+      partial_sign(message, keys)
+      true
     end
 
     private
 
     def serialize_message
-      accounts = collect_accounts
+      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
 
-      message_data = []
-      message_data << Base58.base58_to_binary(@recent_blockhash)
-      message_data << [accounts.length].pack("C")
+    def fetch_message_data
+      program_ids = []
+      account_metas= []
 
-      accounts.each do |account|
-        message_data << account
+      instructions.each do |instruction|
+        account_metas += instruction.keys
+        program_ids.push(instruction.program_id) unless program_ids.include?(instruction.program_id)
       end
 
-      message_data << [@instructions.length].pack("C")
+      # Append programID account metas
+      append_program_id(program_ids, account_metas)
 
-      @instructions.each do |instruction|
-        message_data << instruction.serialize
+      # 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
 
-      message_data.join
+    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 collect_accounts
-      accounts = []
-      accounts << Base58.base58_to_binary(@fee_payer) if @fee_payer
+    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
 
-      @instructions.each do |instruction|
-        instruction.keys.each do |key_meta|
-          pubkey_binary = Base58.base58_to_binary(key_meta[:pubkey])
-          accounts << pubkey_binary unless accounts.include?(pubkey_binary)
+    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
 
-      accounts.uniq
+    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
-  end
-end
 
-class Base58
-  ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.freeze
+    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
 
-  # Checks if a string contains only valid Base58 characters
-  def self.valid?(base58_str)
-    base58_str.chars.all? { |char| ALPHABET.include?(char) }
+      @signatures[index][:signature] = signature
+    end
   end
 end

data/lib/solana_ruby/transaction_helper.rb

@@ -1,29 +1,138 @@
 module SolanaRuby
   class TransactionHelper
     require 'base58'
-    PROGRAM_ID = '11111111111111111111111111111111'
+    require 'pry'
 
-    def self.create_transfer(from_pubkey, to_pubkey, lamports, program_id = PROGRAM_ID)
-      transfer_instruction = TransactionInstruction.new(
+    # 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: program_id,
-        data: [2, lamports].pack('CQ<')  # Instruction type 2 (transfer) + lamports (u64)
+        program_id: SYSTEM_PROGRAM_ID,
+        data: data
       )
-      transfer_instruction
     end
 
-    # Helper to construct a new transaction
-    def self.new_transaction(from_pubkey, to_pubkey, lamports, recent_blockhash, program_id = PROGRAM_ID)
+    # 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
 
-      transfer_instruction = create_transfer(from_pubkey, to_pubkey, lamports, program_id)
+    # 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/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.beta4"
+  VERSION = "2.0.0beta1"
 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.beta4
+  version: 2.0.0beta1
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-11 00:00:00.000000000 Z
+date: 2024-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
@@ -229,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
@@ -240,9 +246,11 @@ files:
 - 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
@@ -251,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
@@ -273,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