solana-ruby-web3js 1.0.1.beta2 → 1.0.1.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4523cc4b31deed37187c1f16585843ad9cb30fb65fa6e1ffd623f40a77cba0b
-  data.tar.gz: 95b7f14f5202f681d19e8ce09c466660d583fd84a4fb82213b77c1eff633164e
+  metadata.gz: 2ca6cbe9f7024efc46fc77b926caa77368c337d69f12b2d5bde3434cacd8be99
+  data.tar.gz: 7e4823b24785b3ec0d54f96f2a9b43b02cbdbedfe4732bf674249918b08beeab
 SHA512:
-  metadata.gz: f5e042632802df702a40a514f7fae3d0c2c5d3d3d6cbe563e94f5a8d5b8be2e9bb8b61b0da2cec398f3c9d9f71247162f281e31770d2559d41a9ed85596142eb
-  data.tar.gz: be74a999f1eebc3eb4cded2b4d594aa9a90dca57589af40ce360636efe3cb150317e948ab8b9f95eba8485846a56dde9405d65465615e34ad5c246da8c84e90e
+  metadata.gz: 1d75c69661f9bd7353c9251d8cb7615785d5233d7832a1e596c02997a42b1f07dbfb9600abb45ea2b04dfc8d80ddbe2167e91e2504c436ca27e99ec30a4679f2
+  data.tar.gz: e4784c227e3e24fd2bcaf79734b42602540c39c8ed4338fc5a53d740b2077aedeb76e7bb62c84d7cf4bc54c5a044281293d02adfd92fc487483d428ab03c1ea5

data/Gemfile.lock

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

data/README.md

@@ -67,33 +67,86 @@ For a more detailed overview of Solana's available RPC methods, visit the offici
 
 ### Options Parameter
 
-The options parameter is a hash that can include the following fields:
+The options parameter is a hash that can include the following fields and more, allowing for customized responses:
 
-commitment: Specifies the level of commitment desired when querying state.
+- **commitment**: Specifies the level of commitment desired when querying state. Options include:
 
-Options include:
+    - 'finalized': Query the most recent block confirmed by supermajority of the cluster.
+    - 'confirmed': Query the most recent block that has been voted on by supermajority of the cluster.
+    - 'processed': Query the most recent block regardless of cluster voting.
 
-    'finalized': Query the most recent block confirmed by supermajority of the cluster.
-    'confirmed': Query the most recent block that has been voted on by supermajority of the cluster.
-    'processed': Query the most recent block regardless of cluster voting.
+- **encoding**: Defines the format of the returned account data. Possible values include:
 
-encoding: Defines the format of the returned account data. Possible values include:
+    - 'jsonParsed': Returns data in a JSON-parsed format.
+    - 'base64': Returns raw account data in Base64 encoding.
+    - 'base64+zstd': Returns compressed Base64 data.
 
-    'jsonParsed': Returns data in a JSON-parsed format.
-    'base64': Returns raw account data in Base64 encoding.
-    'base64+zstd': Returns compressed Base64 data.
+- **epoch**: Specify the epoch when querying for certain information like epoch details.
+
+- **skipPreflight**: If true, skip the preflight transaction verification. Preflight ensures that a transaction is valid before sending it to the network, but skipping this can result in faster submission.
+
+- **maxRetries**: Specify how many times to retry sending a transaction before giving up.
+
+- **recentBlockhash**: Provide a custom recent blockhash for a transaction if not relying on the default.
 
 By providing options, you can control the nature of the returned data and the reliability of the query.
 
 ### Filters Parameter
 
-The filters parameter allows you to specify conditions for querying token accounts. Some common filter types include:
+The filters parameter allows you to specify conditions when querying accounts and other resources. Here are some common filters:
+
+#### Token Accounts by Owner
+
+    # Replace 'owner_pubkey' with the owner's public key
+    owner_pubkey = 'Fg6PaFpoGXkYsidMpWxTWqSKJf6KJkUxX92cnv7WMd2J'
+    
+    # Query for token accounts owned by this public key
+    filters = [{ mint: 'TokenMintPublicKey' }]
+    
+    result = client.get_token_accounts_by_owner(owner_pubkey, filters)
+    
+    puts result
+
+#### Account Filters
+
+You can use the filters parameter to apply conditions for certain queries, such as fetching token accounts by a specific owner or a specific token program. Below are examples of filters that can be used in different queries.
+
+#### Mint Filter
+
+- Filter accounts by a specific token mint.
+
+    ``filters = [{ mint: 'TokenMintPublicKey' }]``
+
+    ``result = client.get_token_accounts_by_owner(owner_pubkey, filters)``
+
+#### Program Filter
+
+- Filter accounts associated with a particular program, such as the token program.
+
+    ``filters = [{ programId: 'TokenProgramPublicKey' }]``
+
+    ``result = client.get_token_accounts_by_owner(owner_pubkey, filters)``
+
+#### Data Size Filter
+
+- Filter accounts by the exact size of the account data.
+
+    ``filters = [{ dataSize: 165 }]``
+
+    ``result = client.get_program_accounts('ProgramPublicKey', filters)``
+
+#### Memcmp Filter
+
+- Filter by matching a specific slice of bytes at a given offset in account data.
 
-    # Mint Filter: Filter by a specific token mint. This retrieves accounts holding tokens of that mint.
-    filters = { mint: 'TokenMintPublicKey' }
+    ``filters = [{
+            memcmp: {
+                offset: 0,
+                bytes: 'Base58EncodedBytes'
+            }
+        }]``
 
-    # Program Filter: Filter by a specific program (e.g., the token program).
-    filters = { programId: 'TokenProgramPublicKey' }
+    ``result = client.get_program_accounts('ProgramPublicKey', filters)``
 
 ## WebSocket Methods
 

data/lib/solana_ruby/keypair.rb

@@ -0,0 +1,39 @@
+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_hex = signing_key.to_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
+      }
+    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),
+        private_key: private_key_hex
+      }
+    end
+  end
+end

data/lib/solana_ruby/transaction.rb

@@ -0,0 +1,108 @@
+module SolanaRuby
+  class Transaction
+    require 'rbnacl'
+
+    attr_accessor :instructions, :signatures, :fee_payer, :recent_blockhash
+
+    def initialize
+      @instructions = []
+      @signatures = []
+      @fee_payer = nil
+      @recent_blockhash = nil
+    end
+
+    def add_instruction(instruction)
+      @instructions << instruction
+    end
+
+    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)
+      @recent_blockhash = blockhash  # Store as-is for similar reasons
+    end
+
+    def serialize
+      raise "Recent blockhash not set" if @recent_blockhash.nil?
+      raise "Fee payer not set" if @fee_payer.nil?
+
+      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")
+
+      @instructions.each do |instruction|
+        serialized_instruction = instruction.serialize
+        raise "Instruction serialization failed" if serialized_instruction.nil?
+        transaction_data << serialized_instruction
+      end
+
+      serialized = transaction_data.join
+      puts "Serialized Transaction Data: #{serialized.bytes.inspect}"  # Debugging output
+
+      serialized
+    end
+
+    def sign(private_key_hex)
+      private_key_bytes = [private_key_hex].pack('H*')
+      signing_key = RbNaCl::Signatures::Ed25519::SigningKey.new(private_key_bytes)
+
+      message = serialize_message
+      signature = signing_key.sign(message)
+
+      @signatures << signature  # Store as binary
+      Base58.binary_to_base58(signature)  # Convert to Base58 for external use
+    end
+
+    private
+
+    def serialize_message
+      accounts = collect_accounts
+
+      message_data = []
+      message_data << Base58.base58_to_binary(@recent_blockhash)
+      message_data << [accounts.length].pack("C")
+
+      accounts.each do |account|
+        message_data << account
+      end
+
+      message_data << [@instructions.length].pack("C")
+
+      @instructions.each do |instruction|
+        message_data << instruction.serialize
+      end
+
+      message_data.join
+    end
+
+    def collect_accounts
+      accounts = []
+      accounts << Base58.base58_to_binary(@fee_payer) if @fee_payer
+
+      @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)
+        end
+      end
+
+      accounts.uniq
+    end
+  end
+end
+
+class Base58
+  ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.freeze
+
+  # Checks if a string contains only valid Base58 characters
+  def self.valid?(base58_str)
+    base58_str.chars.all? { |char| ALPHABET.include?(char) }
+  end
+end

data/lib/solana_ruby/transaction_helper.rb

@@ -0,0 +1,29 @@
+module SolanaRuby
+  class TransactionHelper
+    require 'base58'
+    PROGRAM_ID = '11111111111111111111111111111111'
+
+    def self.create_transfer(from_pubkey, to_pubkey, lamports, program_id = PROGRAM_ID)
+      transfer_instruction = 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)
+      )
+      transfer_instruction
+    end
+
+    # Helper to construct a new transaction
+    def self.new_transaction(from_pubkey, to_pubkey, lamports, recent_blockhash, program_id = PROGRAM_ID)
+      transaction = Transaction.new
+      transaction.set_fee_payer(from_pubkey)
+      transaction.set_recent_blockhash(recent_blockhash)
+
+      transfer_instruction = create_transfer(from_pubkey, to_pubkey, lamports, program_id)
+      transaction.add_instruction(transfer_instruction)
+      transaction
+    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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolanaRuby
-  VERSION = "1.0.1.beta2"
+  VERSION = "1.0.1.beta4"
 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-web3js
 version: !ruby/object:Gem::Version
-  version: 1.0.1.beta2
+  version: 1.0.1.beta4
 platform: ruby
 authors:
 - BuildSquad
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-03 00:00:00.000000000 Z
+date: 2024-11-11 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
@@ -211,6 +239,10 @@ 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/transaction.rb
+- lib/solana_ruby/transaction_helper.rb
+- lib/solana_ruby/transaction_instruction.rb
 - lib/solana_ruby/version.rb
 - lib/solana_ruby/web_socket_client.rb
 - lib/solana_ruby/web_socket_handlers.rb