hyperliquid 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea2358a056d774b7c16f5630111fe847204db819d4cdb6c0c9a3c9d601e9977d
-  data.tar.gz: cd896dd17790c385765d0484c5d1d57c8589ac4b8b8b238eae624dde135f47b1
+  metadata.gz: fa1051cb2277e69795819ed2ae8564e89ac3e6b34139d9112a8273f0604d2fa1
+  data.tar.gz: 072416d6751fa766f0b4eeb5c416365ea96652b980301932d3ab32a549750b24
 SHA512:
-  metadata.gz: dce41aa6805c512465cba2a66a33a277ad84b6130b06ca80641f45b45ecd8cea6e89d30a1ad592fd30d93f90ef06c4369633ba35df98b6b0429ccd3bfb1377c0
-  data.tar.gz: 913c99238363b115273cfd31e2ec3ae8fe61d3de9b2e7367cd0a295b771d75e3b5f5dc050f97d535dfa66b10bae6fcda52dc54835c0e61ffee8b5f14fea2ba2a
+  metadata.gz: 41059a1ef505d93e061fdd575f42ca340c6eb1e8100f14adf176c9512bd65ce4c1afdd1ddeeb831a1833bce63b9ca065f602681c673bba9b96f7a298130b05a0
+  data.tar.gz: 9cfb58786186bafc873dc9dd1747c2b87a645770fddc8d759ea3b5420e7367f1118de056de8e470dbe8bff06e44e55033ce063d839a3c81803fc418e3be68890

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Ruby Hyperliquid SDK Changelog]
 
+## [1.7.0] - 2026-06-11
+
+### New Exchange actions
+
+- `Exchange#authorize_aqav2_role(token:, role:)` — L1 action authorizing an AQAv2 role (e.g. `"treasury"`); supports `expires_after`.
+- `Exchange#staking_link_disable_trading_user(trading_user:)` — user-signed action linking a staking account to a trading user (irreversible). Adds `STAKING_LINK_DISABLE_TRADING_USER_TYPES`.
+- `Exchange#finalize_evm_contract(input:)` — L1 action linking a HyperCore spot token to a HyperEVM ERC-20 contract. Accepts a `Hash` (`{create: {nonce:}}`) or string variant (`"firstStorageSlot"` / `"customStorageSlot"`).
+- HIP-4 `userOutcome` variants (L1 actions, not user-signed): `split_outcome(question:, outcome:, amount:)`, `merge_outcome(question:, amount:)`, `merge_question(question:, amount:)`, `negate_outcome(question:, outcome:, amount:)`. `merge_outcome` and `merge_question` accept `amount: nil` for the max-available case.
+
+### New Info methods
+
+- `Info#settled_outcome(outcome:)` — returns settled prediction-market outcome data.
+
+### Fixes
+
+- `Signing::MultiSig.payload_action` now normalizes `userSetAbstraction` long-form abstraction values (`"disabled"`, `"unifiedAccount"`, `"portfolioMargin"`) to their wire enum equivalents (`"i"`, `"u"`, `"p"`) in the L1 payload posted to `/exchange`, matching Python SDK 0.24.0. Pre-translated short codes pass through unchanged.
+
 ## [1.6.0] - 2026-05-26
 
 ### New Exchange actions

data/lib/hyperliquid/exchange.rb

@@ -1017,6 +1017,31 @@ module Hyperliquid
       post_action(action, signature, nonce, nil)
     end
 
+    # Permanently disable a linked trading user, locking its funds
+    # (`stakingLinkDisableTradingUser` user-signed action). Sent by the staking user.
+    # After 1 year of locking, funds from the trading user are automatically transferred
+    # to the staking user. **This action is irreversible.** The `trading_user` address is
+    # lowercased to match the address-field convention used by other user-signed actions.
+    # @param trading_user [String] Trading user address to disable
+    # @return [Hash] Exchange response
+    def staking_link_disable_trading_user(trading_user:)
+      nonce = timestamp_ms
+      trading_user_lower = trading_user.downcase
+      action = {
+        type: 'stakingLinkDisableTradingUser',
+        signatureChainId: '0x66eee',
+        hyperliquidChain: Signing::EIP712.hyperliquid_chain(testnet: @testnet),
+        tradingUser: trading_user_lower,
+        nonce: nonce
+      }
+      signature = @signer.sign_user_signed_action(
+        { tradingUser: trading_user_lower, nonce: nonce },
+        'HyperliquidTransaction:StakingLinkDisableTradingUser',
+        Signing::EIP712::STAKING_LINK_DISABLE_TRADING_USER_TYPES
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
     # Move assets between DEX instances on behalf of an agent's principal
     # (`agentSendAsset` L1 action). Unlike `send_asset` (which is user-signed),
     # this is signed by an agent and the destination must equal the agent's
@@ -1237,6 +1262,104 @@ module Hyperliquid
       post_action(action, signature, nonce, nil)
     end
 
+    # HIP-4: split `amount` quote tokens into `amount` Yes and `amount` No shares
+    # of an outcome (`userOutcome` L1 action, splitOutcome variant).
+    # @param outcome [Integer] Outcome identifier
+    # @param amount [String, Numeric] Amount of quote tokens to split (UnsignedDecimal, coerced via to_s)
+    # @return [Hash] Exchange response
+    def split_outcome(outcome:, amount:)
+      nonce = timestamp_ms
+      action = {
+        type: 'userOutcome',
+        splitOutcome: { outcome: outcome, amount: amount.to_s }
+      }
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # HIP-4: merge `amount` Yes and `amount` No shares of an outcome back into
+    # `amount` quote tokens (`userOutcome` L1 action, mergeOutcome variant).
+    # Pass `amount: nil` to merge the maximum available.
+    # @param outcome [Integer] Outcome identifier
+    # @param amount [String, Numeric, nil] Amount of shares to merge; nil = maximum available
+    # @return [Hash] Exchange response
+    def merge_outcome(outcome:, amount: nil)
+      nonce = timestamp_ms
+      action = {
+        type: 'userOutcome',
+        mergeOutcome: { outcome: outcome, amount: amount&.to_s }
+      }
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # HIP-4: merge `amount` Yes shares from every outcome of a question into
+    # `amount` quote tokens (`userOutcome` L1 action, mergeQuestion variant).
+    # Pass `amount: nil` to merge the maximum available.
+    # @param question [Integer] Question identifier
+    # @param amount [String, Numeric, nil] Amount of shares to merge; nil = maximum available
+    # @return [Hash] Exchange response
+    def merge_question(question:, amount: nil)
+      nonce = timestamp_ms
+      action = {
+        type: 'userOutcome',
+        mergeQuestion: { question: question, amount: amount&.to_s }
+      }
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # HIP-4: convert `amount` No shares from one outcome of a question into
+    # `amount` Yes shares of every other outcome associated with that question
+    # (`userOutcome` L1 action, negateOutcome variant).
+    # @param question [Integer] Question identifier
+    # @param outcome [Integer] Outcome identifier whose No shares are being negated
+    # @param amount [String, Numeric] Amount of No shares to negate (UnsignedDecimal, coerced via to_s)
+    # @return [Hash] Exchange response
+    def negate_outcome(question:, outcome:, amount:)
+      nonce = timestamp_ms
+      action = {
+        type: 'userOutcome',
+        negateOutcome: { question: question, outcome: outcome, amount: amount.to_s }
+      }
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
+    # Finalize the link between a HyperCore spot token and an ERC-20 contract on
+    # HyperEVM (`finalizeEvmContract` L1 action). `input` selects the verification method
+    # and is passed through verbatim — accepts a Hash `{ create: { nonce: <int> } }` for an
+    # EOA-deployed contract, or one of the strings `"firstStorageSlot"` / `"customStorageSlot"`
+    # for contracts that store the finalizer address in a known storage slot.
+    # @param token [Integer] HyperCore spot token identifier to link
+    # @param input [Hash, String] Verification method (see above)
+    # @return [Hash] Exchange response
+    def finalize_evm_contract(token:, input:)
+      nonce = timestamp_ms
+      action = {
+        type: 'finalizeEvmContract',
+        token: token,
+        input: input
+      }
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
     # Opt in or out of spot dusting (`spotUser` L1 action).
     # Spot dusting is the protocol's automatic conversion of small spot balances.
     # Despite the generic action name, this method exclusively toggles that opt-out flag.
@@ -1252,6 +1375,20 @@ module Hyperliquid
       post_action(action, signature, nonce, nil)
     end
 
+    # Authorize an AQAv2 role (`authorizeAqav2Role` L1 action).
+    # @param token [Integer] Token identifier
+    # @param role [String] Role to authorize ("technical" or "treasury")
+    # @return [Hash] Exchange response
+    def authorize_aqav2_role(token:, role:)
+      nonce = timestamp_ms
+      action = { type: 'authorizeAqav2Role', token: token.to_i, role: role }
+      signature = @signer.sign_l1_action(
+        action, nonce,
+        expires_after: @expires_after
+      )
+      post_action(action, signature, nonce, nil)
+    end
+
     # Clear the asset metadata cache
     # Call this if metadata has been updated
     def reload_metadata!

data/lib/hyperliquid/info.rb

@@ -515,6 +515,13 @@ module Hyperliquid
       @client.post(Constants::INFO_ENDPOINT, { type: 'outcomeMeta' })
     end
 
+    # Retrieve information about a settled outcome
+    # @param outcome [Integer] Outcome identifier
+    # @return [Hash, nil] Hash with spec, settleFraction, and details; or nil if not settled
+    def settled_outcome(outcome:)
+      @client.post(Constants::INFO_ENDPOINT, { type: 'settledOutcome', outcome: outcome.to_i })
+    end
+
     # Retrieve a user's funding history
     # @param user [String]
     # @param start_time [Integer]

data/lib/hyperliquid/signing/eip712.rb

@@ -130,6 +130,14 @@ module Hyperliquid
         ]
       }.freeze
 
+      STAKING_LINK_DISABLE_TRADING_USER_TYPES = {
+        'HyperliquidTransaction:StakingLinkDisableTradingUser': [
+          { name: :hyperliquidChain, type: 'string' },
+          { name: :tradingUser, type: 'address' },
+          { name: :nonce, type: 'uint64' }
+        ]
+      }.freeze
+
       MULTI_SIG_TYPES = {
         'HyperliquidTransaction:SendMultiSig': [
           { name: :hyperliquidChain,   type: 'string'  },

data/lib/hyperliquid/signing/multi_sig.rb

@@ -17,6 +17,16 @@ module Hyperliquid
     module MultiSig
       OUTER_PRIMARY_TYPE = 'HyperliquidTransaction:SendMultiSig'
 
+      # Wire-format normalization for userSetAbstraction inside multi_sig envelopes.
+      # Each co-signer's EIP-712 hash uses the human-readable abstraction string, but the
+      # L1 payload requires the single-char wire enum. Mirrors Python SDK 0.24.0's
+      # `_multi_sig_payload_action`.
+      USER_SET_ABSTRACTION_WIRE_VALUES = {
+        'disabled' => 'i',
+        'unifiedAccount' => 'u',
+        'portfolioMargin' => 'p'
+      }.freeze
+
       # Build the outer multi-sig envelope (the action body posted to /exchange).
       # @param inner_action [Hash] The wrapped action (any L1 or user-signed action body)
       # @param multi_sig_user [String] Address of the multi-sig user (lowercased)
@@ -31,11 +41,26 @@ module Hyperliquid
           payload: {
             multiSigUser: multi_sig_user.downcase,
             outerSigner: outer_signer.downcase,
-            action: inner_action
+            action: payload_action(inner_action)
           }
         }
       end
 
+      # Normalize an inner action for the L1 payload. Currently only userSetAbstraction
+      # needs translation (long-form abstraction string → wire enum); all other actions
+      # pass through verbatim.
+      # @param inner_action [Hash] Inner action (symbol or string keys)
+      # @return [Hash] Possibly-normalized copy (or the original if no change needed)
+      def self.payload_action(inner_action)
+        return inner_action unless (inner_action[:type] || inner_action['type']) == 'userSetAbstraction'
+
+        key = inner_action.key?(:abstraction) ? :abstraction : 'abstraction'
+        abstraction = inner_action[key]
+        return inner_action unless USER_SET_ABSTRACTION_WIRE_VALUES.key?(abstraction)
+
+        inner_action.merge(key => USER_SET_ABSTRACTION_WIRE_VALUES[abstraction])
+      end
+
       # Compute the multiSigActionHash that the submitter signs over.
       # Mirrors Python's `sign_multi_sig_action`: action_hash(envelope - type, vault, nonce, expires).
       # @param envelope [Hash] The multi-sig envelope (will have :type stripped before hashing)

data/lib/hyperliquid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hyperliquid
-  VERSION = '1.6.0'
+  VERSION = '1.7.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hyperliquid
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - carter2099