solana-ruby-web3js 1.0.1.beta4 → 2.0.0beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ca6cbe9f7024efc46fc77b926caa77368c337d69f12b2d5bde3434cacd8be99
-  data.tar.gz: 7e4823b24785b3ec0d54f96f2a9b43b02cbdbedfe4732bf674249918b08beeab
+  metadata.gz: 6bb6650de7a5beae14649fe9cfac20973923d0be4c4f74e9d1e8f373e70842b9
+  data.tar.gz: c3ad4316d61d4326327bb281a3eb64991011ae14d51a7974de6eaf9705d4ffa5
 SHA512:
-  metadata.gz: 1d75c69661f9bd7353c9251d8cb7615785d5233d7832a1e596c02997a42b1f07dbfb9600abb45ea2b04dfc8d80ddbe2167e91e2504c436ca27e99ec30a4679f2
-  data.tar.gz: e4784c227e3e24fd2bcaf79734b42602540c39c8ed4338fc5a53d740b2077aedeb76e7bb62c84d7cf4bc54c5a044281293d02adfd92fc487483d428ab03c1ea5
+  metadata.gz: 94c8304f1d05d7cbd8ec22947d98ede21c1892b210ad5cdb43f3e6293f4c6ab288c8aa83b1ba6e40a28d08a191a32ba775966eeb370631d02112cac981309fb6
+  data.tar.gz: '0085b47b4f44786e0bd0af77827a12cbc191744a16aff61448cafff641a53efa798677ef51b3748966f76547b883fd767d3f48ffe5297f8519cc08eb1ee81e90'

data/Gemfile.lock

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

data/README.md

@@ -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 Mainnet, Devnet, or Testnet transactions, ensure that the sender's account is funded with sufficient lamports using the Solana airdrop feature.
+- An initialized client to interact with the Solana blockchain.
+
+#### Example Usage:
+
+    require 'solana_ruby'
+
+    # Initialize the client (defaults to Mainnet(https://api.mainnet-beta.solana.com))
+    client = SolanaRuby::HttpClient.new('https://api.devnet.solana.com')
+
+    # Fetch the recent blockhash
+    recent_blockhash = client.get_latest_blockhash["blockhash"]
+
+    # Generate or fetch the sender's keypair
+    # Option 1: Generate a new keypair
+    sender_keypair = SolanaRuby::Keypair.generate
+    # Option 2: Use an existing private key
+    # sender_keypair = SolanaRuby::Keypair.from_private_key("InsertPrivateKeyHere")
+    
+    sender_pubkey = sender_keypair[:public_key]
+
+
+    # Airdrop some lamports to the sender's account when needed.
+    lamports = 10 * 1_000_000_000
+    sleep(1)
+    result = client.request_airdrop(sender_pubkey, lamports)
+    puts "Solana Balance #{lamports} lamports added sucessfully for the public key: #{sender_pubkey}"
+    sleep(10)
+
+
+    # Generate or use an existing receiver's public key
+    # Option 1: Generate a new keypair for the receiver
+    receiver_keypair = SolanaRuby::Keypair.generate
+    receiver_pubkey = receiver_keypair[:public_key]
+    # Option 2: Use an existing public key
+    # receiver_pubkey = 'InsertExistingPublicKeyHere'
+
+    transfer_lamports = 1 * 1_000_000
+    puts "Payer's full private key: #{sender_keypair[:full_private_key]}"
+    puts "Receiver's full private key: #{receiver_keypair[:full_private_key]}"
+    puts "Receiver's Public Key: #{receiver_keypair[:public_key]}"
+
+    # Create a new transaction
+    transaction = SolanaRuby::TransactionHelper.sol_transfer(
+      sender_pubkey,
+      receiver_pubkey,
+      transfer_lamports,
+      recent_blockhash
+    )
+
+    # Get the sender's private key (ensure it's a string)
+    private_key = sender_keypair[:private_key]
+    puts "Private key type: #{private_key.class}, Value: #{private_key.inspect}"
+
+    # Sign the transaction
+    signed_transaction = transaction.sign([sender_keypair])
+
+    # Send the transaction to the Solana network
+    sleep(5)
+    response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+    puts "Response: #{response}"
+

data/lib/solana_ruby/data_types/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 },   # 8-bit unsigned integer
+        32 => { directive: 'L<', size: 4 }, # 32-bit little-endian unsigned integer
+        64 => { directive: 'Q<', size: 8 }  # 64-bit little-endian unsigned integer
+      }
+
+      def initialize(bits)
+        @bits = bits
+        type = BITS[@bits]
+        raise "Unsupported size. Supported sizes: #{BITS.keys.join(', ')} bits" unless type
+        @size = type[:size]
+        @directive = type[:directive]
+      end
+
+      # Serialize the unsigned integer into properly aligned bytes
+      def serialize(obj)
+        raise "Can only serialize integers" unless obj.is_a?(Integer)
+        raise "Cannot serialize negative integers" if obj.negative?
+
+        if obj >= 256**@size
+          raise "Integer too large to fit in #{@size} bytes"
+        end
+
+        [obj].pack(@directive).bytes
+      end
+
+      # Deserialize bytes into the unsigned integer
+      def deserialize(bytes)
+        raise "Invalid serialization (expected #{@size} bytes, got #{bytes.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,29 @@
+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
+
+    def blob32
+      Blob.new(32)
+    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,266 @@ 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(keypairs)
+      raise 'No signers' unless keypairs.any?
 
-      message = serialize_message
-      signature = signing_key.sign(message)
+      keys = keypairs.uniq { |kp| kp[: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
 
-      message_data = []
-      message_data << Base58.base58_to_binary(@recent_blockhash)
-      message_data << [accounts.length].pack("C")
+    def compile
+      message = compile_message
+      signed_keys = message.account_keys.slice(0, message.header[:num_required_signatures])
 
-      accounts.each do |account|
-        message_data << account
+      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
 
-      message_data << [@instructions.length].pack("C")
+      @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
+
+      # add instruction structure
+      instructs = add_instructs
+      
+      message_data = Message.new(
+        header: @header,
+        account_keys: @account_keys,
+        recent_blockhash: recent_blockhash,
+        instructions: instructs
+      )
+     message_data
+    end
+
+    def check_for_errors
+      raise 'Transaction recent_blockhash required' unless recent_blockhash
 
-      @instructions.each do |instruction|
-        message_data << instruction.serialize
+      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?
 
-      message_data.join
+      instructions.each_with_index do |instruction, i|
+        raise("Transaction instruction index #{i} has undefined program id") unless instruction.program_id
+      end
     end
 
-    def collect_accounts
-      accounts = []
-      accounts << Base58.base58_to_binary(@fee_payer) if @fee_payer
+    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)
 
-      @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)
+      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 = split_keys(unique_metas, signed_keys, unsigned_keys)
+      @account_keys = signed_keys + unsigned_keys
+    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
 
-      accounts.uniq
+    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
-  end
-end
 
-class Base58
-  ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.freeze
+    def disallow_signers(signatures, unique_metas)
+      signatures.each do |signature|
+        unique_index = unique_metas.find_index{ |x| x[:pubkey] == signature[:public_key] }
 
-  # Checks if a string contains only valid Base58 characters
-  def self.valid?(base58_str)
-    base58_str.chars.all? { |char| ALPHABET.include?(char) }
+        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
+      {
+        num_required_signatures: num_required_signatures,
+        num_readonly_signed_accounts: num_readonly_signed_accounts,
+        num_readonly_unsigned_accounts: num_readonly_unsigned_accounts,
+      }
+    end
+
+    def partial_sign(message, keys)
+      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

@@ -1,29 +1,152 @@
 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: :uint32,
+        lamports: :uint64,
+        space: :uint64,
+        program_id: :blob32
+      }
+    }
+
+    # Method to create a system account (e.g., for SPL token or SOL)
+    def self.account_instruction(from_pubkey, new_account_pubkey, lamports, space, program_id)
+      # Encode the instruction data
+      instruction_data = encode_data(
+        INSTRUCTION_LAYOUTS[:create_account],
+        {
+          instruction: 0,      # '0' corresponds to the Create Account instruction
+          lamports: lamports,  # The amount of lamports to transfer to the new account
+          space: space,        # Amount of space allocated for the account's data
+          program_id: Base58.base58_to_binary(program_id, :bitcoin).bytes # Convert public key to binary
+        }
+      )
+
+      # Construct the transaction instruction
+      create_account_instruction = TransactionInstruction.new(
+        keys: [
+          { pubkey: from_pubkey, is_signer: true, is_writable: true },  # Funder's account
+          { pubkey: new_account_pubkey, is_signer: true, is_writable: true } # New account
+        ],
+        program_id: program_id,  # Use Solana's system program for account creation
+        data: instruction_data   # Encoded instruction data
+      )
+
+      # return instruction data
+      create_account_instruction
+    end
+
+
+    def self.create_account(from_pubkey, new_account_pubkey, lamports, space, recent_blockhash, program_id = SYSTEM_PROGRAM_ID)
+      # Create the transaction
+      transaction = Transaction.new
+      transaction.set_fee_payer(from_pubkey)
+      transaction.set_recent_blockhash(recent_blockhash)
+
+      # Add the create account instruction to the transaction
+      instruction = account_instruction(from_pubkey, new_account_pubkey, lamports, space, program_id)
+      transaction.add_instruction(instruction)
+      
+      # return the transaction for signing
+      transaction
+    end
+
+    # Method to create a SOL transfer instruction
+    def self.transfer_sol_instruction(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.sol_transfer(from_pubkey, to_pubkey, lamports, recent_blockhash)
       transaction = Transaction.new
       transaction.set_fee_payer(from_pubkey)
       transaction.set_recent_blockhash(recent_blockhash)
+      transfer_instruction = transfer_sol_instruction(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(payer, mint, owner)
+      data = [0, 0, 0, 0]  # No data required for account creation
+      create_account_instruction = TransactionInstruction.new(
+        keys: [
+          { pubkey: payer, is_signer: true, is_writable: true },
+          { pubkey: associated_token, is_signer: false, is_writable: true },
+          { pubkey: owner, is_signer: false, is_writable: false },
+          { pubkey: mint, is_signer: false, is_writable: false },
+          { pubkey: 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.0beta2"
 end

data/transaction_testing/create_account.rb

@@ -0,0 +1,57 @@
+# 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 }
+
+# Initialize Solana client
+client = SolanaRuby::HttpClient.new('http://127.0.0.1:8899')
+
+# Fetch the recent blockhash
+recent_blockhash = client.get_latest_blockhash["blockhash"]
+puts "Recent Blockhash: #{recent_blockhash}"
+
+# Sender keypair and public key
+private_key = "d22867a84ee1d91485a52c587793002dcaa7ce79a58bb605b3af2682099bb778"
+sender_keypair = SolanaRuby::Keypair.from_private_key(private_key)
+sender_pubkey = sender_keypair[:public_key]
+puts "Sender Public Key: #{sender_pubkey}"
+
+# Check sender's account balance
+balance = client.get_balance(sender_pubkey)
+puts "Sender account balance: #{balance} lamports"
+if balance == 0
+  puts "Balance is zero, waiting for balance update..."
+  sleep(10)
+end
+
+# new keypair and public key (new account)
+new_account = SolanaRuby::Keypair.generate
+new_account_pubkey = new_account[:public_key]
+puts "New Account Public Key: #{new_account_pubkey}"
+
+# Parameters for account creation
+lamports = 1 * 1_000_000_000 # Lamports to transfer
+space = 165 # Space allocation (bytes)
+program_id = SolanaRuby::TransactionHelper::SYSTEM_PROGRAM_ID
+
+# Create and sign the transaction
+transaction = SolanaRuby::TransactionHelper.create_account(
+  sender_pubkey,
+  new_account_pubkey,
+  lamports,
+  space,
+  recent_blockhash,
+  program_id
+)
+
+# Sign transaction with both sender and new account keypairs
+transaction.sign([sender_keypair, new_account])
+
+# Send the transaction
+puts "Sending transaction..."
+response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+
+# Output transaction results
+puts "Transaction Signature: #{response}"
+puts "New account created successfully with Public Key: #{new_account_pubkey}"
+

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.sol_transfer(
+  sender_pubkey,
+  receiver_pubkey,
+  transfer_lamports,
+  recent_blockhash
+)
+
+# Get the sender's private key (ensure it's a string)
+private_key = sender_keypair[:private_key]
+puts "Private key type: #{private_key.class}, Value: #{private_key.inspect}"
+
+# Sign the transaction
+signed_transaction = transaction.sign([sender_keypair])
+
+# Send the transaction to the Solana network
+sleep(5)
+response = client.send_transaction(transaction.to_base64, { encoding: 'base64' })
+puts "Response: #{response}"
+

data/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.0beta2
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-11 00:00:00.000000000 Z
+date: 2024-11-28 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