solace 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18aca49d63b09deffe93ba871b65d6b816a7c81863b0b0e2b2c2bd29ce709ce6
-  data.tar.gz: 810a45b1324aa282684e4a5d62ea48738ac2b33a6eb87538e2e0458ca2f54593
+  metadata.gz: 378cd7a1cb5958d12bfbe371485f60c12c72e04141bb557a7ef61dde617b0dfe
+  data.tar.gz: e36f6aa0189ff832b3ca440a1a38690984d69081dcde8b9613d632320d481cf5
 SHA512:
-  metadata.gz: 50eeac609077e873b361fdb8ed34459ccbed1b4e44d52ad911803350ea0d2f0e669fcfcb30bcddd6d20e9f54dade972a50907532a108dae7142ecca8475f42fb
-  data.tar.gz: 5fba491757746aa8fad865bae93941f3469148c6a5fc8cb5c984ebccb79934f1b1c3425184ab37ff2342f6215a1d5b1147a9d04f6d9225a96e7c6b34c38d8b0d
+  metadata.gz: 9c15791a7b1967d19f676e594556f19fb29ea1b431c97e9a5f6ddb0c8344b87b4301e402116bd8896da7c14ba50a5f5de1eb5a5791b41df7c4134ee89f397926
+  data.tar.gz: cb1add67763169e8bb498987f3f760def67a5c92e647852f8e5e4308a5a1a41cb046df0aa8a720202d32b7c82bbe6541e945815e6e45738fd63215b23080e2bc

data/lib/solace/composers/associated_token_account_program_create_account_composer.rb

@@ -63,11 +63,12 @@ module Solace
         Constants::SYSTEM_PROGRAM_ID.to_s
       end
 
-      # Extracts the token program id from the constants
-      #
-      # @return [String] The token program id
+      # @return [String] The token program id baked into the ATA's create-account
+      #   instruction (defaults to legacy SPL Token; pass +params[:token_program_id]+
+      #   to create a Token-2022 ATA — note the derived ATA address differs too,
+      #   see {Programs::AssociatedTokenAccount.get_address}).
       def token_program_id
-        Constants::TOKEN_PROGRAM_ID.to_s
+        (params[:token_program_id] || Constants::TOKEN_PROGRAM_ID).to_s
       end
 
       # Extracts the associated token account program id from the constants
@@ -97,13 +98,13 @@ module Solace
       # @return [Solace::Instruction] The instruction
       def build_instruction(account_context)
         Instructions::AssociatedTokenAccount::CreateAccountInstruction.build(
-          funder_index: account_context.index_of(funder),
-          owner_index: account_context.index_of(owner),
-          mint_index: account_context.index_of(mint),
+          funder_index:                   account_context.index_of(funder),
+          owner_index:                    account_context.index_of(owner),
+          mint_index:                     account_context.index_of(mint),
           associated_token_account_index: account_context.index_of(ata_address),
-          system_program_index: account_context.index_of(system_program_id),
-          token_program_index: account_context.index_of(token_program_id),
-          program_index: account_context.index_of(associated_token_account_program_id)
+          system_program_index:           account_context.index_of(system_program_id),
+          token_program_index:            account_context.index_of(token_program_id),
+          program_index:                  account_context.index_of(associated_token_account_program_id)
         )
       end
     end

data/lib/solace/composers/associated_token_account_program_create_idempotent_account_composer.rb

@@ -4,7 +4,8 @@ module Solace
   module Composers
     # Composer for creating an associated token account program create account instruction with idempotency
     #
-    # This composer resolves and orders the required accounts for a `CreateIdempotentAssociatedTokenAccount` instruction,
+    # This composer resolves and orders the required accounts for a
+    # `CreateIdempotentAssociatedTokenAccount` instruction,
     # sets up their access permissions, and delegates construction to the appropriate
     # instruction builder (`Instructions::AssociatedTokenAccount::CreateIdempotentAssociatedTokenAccountInstruction`).
     #

data/lib/solace/composers/base.rb

@@ -57,7 +57,7 @@ module Solace
       #
       # @param params [Hash] Parameters to pass to the composer constructor
       def initialize(params)
-        @params = params
+        @params          = params
         @account_context = Utils::AccountContext.new
         setup_accounts
       end

data/lib/solace/composers/spl_token_program_close_account_composer.rb

@@ -70,10 +70,10 @@ module Solace
       # @return [Solace::Instruction]
       def build_instruction(account_context)
         Instructions::SplToken::CloseAccountInstruction.build(
-          account_index: account_context.index_of(account),
-          authority_index: account_context.index_of(authority),
+          account_index:     account_context.index_of(account),
+          authority_index:   account_context.index_of(authority),
           destination_index: account_context.index_of(destination),
-          program_index: account_context.index_of(spl_token_program)
+          program_index:     account_context.index_of(spl_token_program)
         )
       end
     end

data/lib/solace/composers/spl_token_program_initialize_mint_composer.rb

@@ -83,11 +83,11 @@ module Solace
       def build_instruction(account_context)
         Instructions::SplToken::InitializeMintInstruction.build(
           mint_account_index: account_context.index_of(mint_account),
-          rent_sysvar_index: account_context.index_of(rent_sysvar),
-          program_index: account_context.index_of(spl_token_program),
-          decimals: decimals,
-          mint_authority: mint_authority,
-          freeze_authority: freeze_authority
+          rent_sysvar_index:  account_context.index_of(rent_sysvar),
+          program_index:      account_context.index_of(spl_token_program),
+          decimals:           decimals,
+          mint_authority:     mint_authority,
+          freeze_authority:   freeze_authority
         )
       end
     end

data/lib/solace/composers/spl_token_program_mint_to_composer.rb

@@ -74,11 +74,11 @@ module Solace
       # @return [Solace::Instruction]
       def build_instruction(account_context)
         Instructions::SplToken::MintToInstruction.build(
-          amount: amount,
-          mint_index: account_context.index_of(mint),
-          destination_index: account_context.index_of(destination),
+          amount:               amount,
+          mint_index:           account_context.index_of(mint),
+          destination_index:    account_context.index_of(destination),
           mint_authority_index: account_context.index_of(mint_authority),
-          program_index: account_context.index_of(spl_token_program)
+          program_index:        account_context.index_of(spl_token_program)
         )
       end
     end

data/lib/solace/composers/spl_token_program_transfer_checked_composer.rb

@@ -99,13 +99,13 @@ module Solace
       # @return [Solace::Instruction]
       def build_instruction(account_context)
         Instructions::SplToken::TransferCheckedInstruction.build(
-          amount: amount,
-          decimals: decimals,
-          to_index: account_context.index_of(to),
-          from_index: account_context.index_of(from),
-          mint_index: account_context.index_of(mint),
+          amount:          amount,
+          decimals:        decimals,
+          to_index:        account_context.index_of(to),
+          from_index:      account_context.index_of(from),
+          mint_index:      account_context.index_of(mint),
           authority_index: account_context.index_of(authority),
-          program_index: account_context.index_of(spl_token_program)
+          program_index:   account_context.index_of(spl_token_program)
         )
       end
     end

data/lib/solace/composers/spl_token_program_transfer_composer.rb

@@ -78,11 +78,11 @@ module Solace
       # @return [Solace::Instruction]
       def build_instruction(account_context)
         Instructions::SplToken::TransferInstruction.build(
-          amount: amount,
-          owner_index: account_context.index_of(owner),
-          source_index: account_context.index_of(source),
+          amount:            amount,
+          owner_index:       account_context.index_of(owner),
+          source_index:      account_context.index_of(source),
           destination_index: account_context.index_of(destination),
-          program_index: account_context.index_of(spl_token_program)
+          program_index:     account_context.index_of(spl_token_program)
         )
       end
     end

data/lib/solace/composers/system_program_create_account_composer.rb

@@ -85,11 +85,11 @@ module Solace
       # @return [Solace::Instruction]
       def build_instruction(account_context)
         Solace::Instructions::SystemProgram::CreateAccountInstruction.build(
-          space: space,
-          lamports: lamports,
-          owner: owner,
-          from_index: account_context.index_of(from),
-          new_account_index: account_context.index_of(new_account),
+          space:                space,
+          lamports:             lamports,
+          owner:                owner,
+          from_index:           account_context.index_of(from),
+          new_account_index:    account_context.index_of(new_account),
           system_program_index: account_context.index_of(system_program)
         )
       end

data/lib/solace/composers/system_program_transfer_composer.rb

@@ -69,9 +69,9 @@ module Solace
       # @return [Solace::Instruction]
       def build_instruction(account_context)
         Instructions::SystemProgram::TransferInstruction.build(
-          lamports: lamports,
-          to_index: account_context.index_of(to),
-          from_index: account_context.index_of(from),
+          lamports:      lamports,
+          to_index:      account_context.index_of(to),
+          from_index:    account_context.index_of(from),
           program_index: account_context.index_of(system_program)
         )
       end

data/lib/solace/composers/token_2022_program_close_account_composer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for creating a Token-2022 Program CloseAccount instruction.
+    #
+    # The CloseAccount instruction closes a token account and transfers remaining
+    # lamports to a destination account. The account must have a balance of zero tokens.
+    #
+    # Required accounts:
+    # - **Account**: token account to close (writable, non-signer)
+    # - **Destination**: account to receive lamports (writable, non-signer)
+    # - **Authority**: account authority (non-writable, signer)
+    #
+    # @example Compose and build a close account instruction
+    #   composer = Token2022ProgramCloseAccountComposer.new(
+    #     account: token_account_address,
+    #     destination: destination_address,
+    #     authority: authority_address
+    #   )
+    #
+    # @since 0.1.5
+    class Token2022ProgramCloseAccountComposer < Base
+      # Extracts the token account address from the params
+      #
+      # @return [String] The token account address
+      def account
+        params[:account].to_s
+      end
+
+      # Extracts the destination address from the params
+      #
+      # @return [String] The destination address
+      def destination
+        params[:destination].to_s
+      end
+
+      # Extracts the authority address from the params
+      #
+      # @return [String] The authority address
+      def authority
+        params[:authority].to_s
+      end
+
+      # @return [String] The Token-2022 program id.
+      def token_2022_program
+        Constants::TOKEN_2022_PROGRAM_ID.to_s
+      end
+
+      # Setup accounts required for close account instruction
+      # Called automatically during initialization
+      #
+      # @return [void]
+      def setup_accounts
+        account_context.add_writable_nonsigner(account)
+        account_context.add_writable_nonsigner(destination)
+        account_context.add_readonly_signer(authority)
+        account_context.add_readonly_nonsigner(token_2022_program)
+      end
+
+      # Build instruction with resolved account indices
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Instructions::Token2022::CloseAccountInstruction.build(
+          account_index:     account_context.index_of(account),
+          authority_index:   account_context.index_of(authority),
+          destination_index: account_context.index_of(destination),
+          program_index:     account_context.index_of(token_2022_program)
+        )
+      end
+    end
+  end
+end

data/lib/solace/composers/token_2022_program_initialize_mint_composer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for initializing a mint via the Token-2022 Program.
+    #
+    # This composer resolves and orders the required accounts for an `InitializeMint`
+    # instruction, sets up their access permissions, and delegates construction to the
+    # appropriate instruction builder (`Instructions::Token2022::InitializeMintInstruction`).
+    #
+    # Required accounts:
+    # - **Mint Account**: the mint account to initialize (writable, non-signer)
+    # - **Rent Sysvar**: the rent sysvar (readonly, non-signer)
+    # - **Program**: Token-2022 program (readonly, non-signer)
+    #
+    # @example Compose and build an initialize_mint instruction
+    #  composer = Token2022ProgramInitializeMintComposer.new(
+    #    decimals: 6,
+    #    mint_authority: mint_authority_pubkey,
+    #    freeze_authority: freeze_authority_pubkey,
+    #    mint_account: mint_address,
+    #  )
+    #
+    # @see Instructions::Token2022::InitializeMintInstruction
+    # @since 0.1.5
+    class Token2022ProgramInitializeMintComposer < Base
+      # Extracts the mint account address from the params
+      #
+      # @return [String] The mint account address
+      def mint_account
+        params[:mint_account].to_s
+      end
+
+      # Returns the rent sysvar address
+      #
+      # @return [String] The rent sysvar address
+      def rent_sysvar
+        Constants::SYSVAR_RENT_PROGRAM_ID.to_s
+      end
+
+      # @return [String] The Token-2022 program id.
+      def token_2022_program
+        Constants::TOKEN_2022_PROGRAM_ID.to_s
+      end
+
+      # Extracts the mint authority address from the params
+      #
+      # @return [String] The mint authority address
+      def mint_authority
+        params[:mint_authority].to_s
+      end
+
+      # Extracts the freeze authority address from the params
+      #
+      # @return [String] The freeze authority address
+      def freeze_authority
+        params[:freeze_authority]&.to_s
+      end
+
+      # Returns the decimals for the mint
+      #
+      # @return [Integer] The decimals for the mint
+      def decimals
+        params[:decimals]
+      end
+
+      # Setup accounts required for the InitializeMint instruction
+      # Called automatically during initialization
+      #
+      # @return [void]
+      def setup_accounts
+        account_context.add_writable_nonsigner(mint_account)
+        account_context.add_readonly_nonsigner(rent_sysvar)
+        account_context.add_readonly_nonsigner(token_2022_program)
+      end
+
+      # Build instruction with resolved account indices
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Instructions::Token2022::InitializeMintInstruction.build(
+          mint_account_index: account_context.index_of(mint_account),
+          rent_sysvar_index:  account_context.index_of(rent_sysvar),
+          program_index:      account_context.index_of(token_2022_program),
+          decimals:           decimals,
+          mint_authority:     mint_authority,
+          freeze_authority:   freeze_authority
+        )
+      end
+    end
+  end
+end

data/lib/solace/composers/token_2022_program_mint_to_composer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for creating a MintTo instruction for the Token-2022 Program.
+    #
+    # This composer builds a MintTo instruction that can be added to a transaction to mint tokens
+    # to a specified token account.
+    #
+    # Required accounts:
+    #  - **Mint**: The mint account (writable, non-signer)
+    #  - **Destination**: The token account to mint to (writable, non-signer)
+    #  - **Mint Authority**: The mint authority account (readonly, signer)
+    #
+    # @example Build a MintTo instruction
+    #   composer = Solace::Composers::Token2022ProgramMintToComposer.new(
+    #     mint: mint,
+    #     destination: destination,
+    #     mint_authority: mint_authority,
+    #     amount: 100
+    #   )
+    #
+    # @since 0.1.5
+    class Token2022ProgramMintToComposer < Base
+      # Extracts the mint address from the params
+      #
+      # @return [String] The mint address
+      def mint
+        params[:mint].to_s
+      end
+
+      # Extracts the destination address from the params
+      #
+      # @return [String] The destination address
+      def destination
+        params[:destination].to_s
+      end
+
+      # Extracts the mint authority address from the params
+      #
+      # @return [String] The mint authority address
+      def mint_authority
+        params[:mint_authority].to_s
+      end
+
+      # @return [String] The Token-2022 program id.
+      def token_2022_program
+        Constants::TOKEN_2022_PROGRAM_ID.to_s
+      end
+
+      # Extracts the amount from the params
+      #
+      # @return [Integer] The amount
+      def amount
+        params[:amount].to_i
+      end
+
+      # Setup accounts required for MintTo instruction
+      # Called automatically during initialization
+      #
+      # @return [void]
+      def setup_accounts
+        account_context.add_writable_nonsigner(mint)
+        account_context.add_writable_nonsigner(destination)
+        account_context.add_readonly_signer(mint_authority)
+        account_context.add_readonly_nonsigner(token_2022_program)
+      end
+
+      # Build instruction with resolved account indices
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Instructions::Token2022::MintToInstruction.build(
+          amount:               amount,
+          mint_index:           account_context.index_of(mint),
+          destination_index:    account_context.index_of(destination),
+          mint_authority_index: account_context.index_of(mint_authority),
+          program_index:        account_context.index_of(token_2022_program)
+        )
+      end
+    end
+  end
+end

data/lib/solace/composers/token_2022_program_transfer_checked_composer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for creating a Token-2022 Program `TransferChecked` instruction.
+    #
+    # This composer resolves and orders the required accounts for a `TransferChecked` instruction,
+    # sets up their access permissions, and delegates construction to the appropriate
+    # instruction builder (`Instructions::Token2022::TransferCheckedInstruction`).
+    #
+    # Required accounts:
+    # - **From**: source token account (writable, non-signer)
+    # - **To**: destination token account (writable, non-signer)
+    # - **Mint**: mint address (readonly, non-signer)
+    # - **Authority**: token owner (writable, signer)
+    # - **Program**: Token-2022 program (readonly, non-signer)
+    #
+    # @example Compose and build a transfer_checked instruction
+    #   composer = Token2022ProgramTransferCheckedComposer.new(
+    #     from: from_address,
+    #     to: to_address,
+    #     mint: mint_address,
+    #     authority: authority_pubkey,
+    #     amount: 1_000_000,
+    #     decimals: 6
+    #   )
+    #
+    # @see Instructions::Token2022::TransferCheckedInstruction
+    # @since 0.1.5
+    class Token2022ProgramTransferCheckedComposer < Base
+      # Extracts the to address from the params
+      #
+      # @return [String] The to address
+      def to
+        params[:to].to_s
+      end
+
+      # Extracts the from address from the params
+      #
+      # @return [String] The from address
+      def from
+        params[:from].to_s
+      end
+
+      # Extracts the authority address from the params
+      #
+      # The authority is the owner of the token account
+      #
+      # @return [String] The authority address
+      def authority
+        params[:authority].to_s
+      end
+
+      # Extracts the mint address from the params
+      #
+      # @return [String] The mint address
+      def mint
+        params[:mint].to_s
+      end
+
+      # @return [String] The Token-2022 program id.
+      def token_2022_program
+        Constants::TOKEN_2022_PROGRAM_ID.to_s
+      end
+
+      # Returns the amount to transfer
+      #
+      # @return [Integer] The amount to transfer
+      def amount
+        params[:amount]
+      end
+
+      # Returns the decimals for the mint of the token
+      #
+      # @return [Integer] The decimals for the mint
+      def decimals
+        params[:decimals]
+      end
+
+      # Setup accounts required for transfer instruction
+      # Called automatically during initialization
+      #
+      # @return [void]
+      def setup_accounts
+        account_context.add_writable_signer(authority)
+        account_context.add_writable_nonsigner(to)
+        account_context.add_writable_nonsigner(from)
+        account_context.add_readonly_nonsigner(mint)
+        account_context.add_readonly_nonsigner(token_2022_program)
+      end
+
+      # Build instruction with resolved account indices
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Instructions::Token2022::TransferCheckedInstruction.build(
+          amount:          amount,
+          decimals:        decimals,
+          to_index:        account_context.index_of(to),
+          from_index:      account_context.index_of(from),
+          mint_index:      account_context.index_of(mint),
+          authority_index: account_context.index_of(authority),
+          program_index:   account_context.index_of(token_2022_program)
+        )
+      end
+    end
+  end
+end

data/lib/solace/composers/token_2022_program_transfer_composer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for creating a Token-2022 Program Transfer instruction.
+    #
+    # This composer resolves and orders the required accounts for a `Transfer` instruction,
+    # sets up their access permissions, and delegates construction to the appropriate
+    # instruction builder (`Instructions::Token2022::TransferInstruction`).
+    #
+    # Required accounts:
+    # - **Owner**: token account owner (writable, signer)
+    # - **Source**: source token account (writable, non-signer)
+    # - **Destination**: destination token account (writable, non-signer)
+    #
+    # @example Compose and build a transfer instruction
+    #   composer = Token2022ProgramTransferComposer.new(
+    #     amount: 1_000_000,
+    #     owner: owner_address,
+    #     source: source_address,
+    #     destination: destination_address,
+    #   )
+    #
+    # @see Instructions::Token2022::TransferInstruction
+    # @since 0.1.5
+    class Token2022ProgramTransferComposer < Base
+      # Extracts the owner address from the params
+      #
+      # @return [String] The owner address
+      def owner
+        params[:owner].to_s
+      end
+
+      # Extracts the source associated token address from the params
+      #
+      # @return [String] The source associated token address
+      def source
+        params[:source].to_s
+      end
+
+      # Extracts the destination associated token address from the params
+      #
+      # @return [String] The destination associated token address
+      def destination
+        params[:destination].to_s
+      end
+
+      # @return [String] The Token-2022 program id.
+      def token_2022_program
+        Constants::TOKEN_2022_PROGRAM_ID.to_s
+      end
+
+      # Returns the lamports to transfer
+      #
+      # @return [Integer] The lamports to transfer
+      def amount
+        params[:amount]
+      end
+
+      # Setup accounts required for transfer instruction
+      # Called automatically during initialization
+      #
+      # @return [void]
+      def setup_accounts
+        account_context.add_writable_signer(owner)
+        account_context.add_writable_nonsigner(source)
+        account_context.add_writable_nonsigner(destination)
+        account_context.add_readonly_nonsigner(token_2022_program)
+      end
+
+      # Build instruction with resolved account indices
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Instructions::Token2022::TransferInstruction.build(
+          amount:            amount,
+          owner_index:       account_context.index_of(owner),
+          source_index:      account_context.index_of(source),
+          destination_index: account_context.index_of(destination),
+          program_index:     account_context.index_of(token_2022_program)
+        )
+      end
+    end
+  end
+end