vault.strategy_tag

Documentation for eth_defi.vault.strategy_tag Python module.

Vault investment strategy classifications.

Protocol-local STRATEGY_TAGS tables use plain lowercase str keys for EVM addresses, for example "0x1234...". Keeping address literals as strings avoids noisy HexAddress(...) constructors while allowing the same mapping convention to be used for native protocol identifiers. The lookup helper normalises adapter-supplied addresses before consulting these tables.

Module Attributes

STRATEGY_TAG_METADATA

Public presentation labels and summaries for every strategy tag.

MORINI_CAPITAL_STRATEGY_TAGS

Morini Capital manages foreign-currency strategies across several vault protocols.

CURATOR_STRATEGY_TAGS

Chain-scoped classifications that follow a curator across vault protocols.

Functions

combine_strategy_tags(defaults, mapping, address)

Combine default and address-specific tags for a native vault export.

lookup_curator_strategy_tags(chain_id, address)

Look up a cross-protocol curator classification.

lookup_strategy_tags(mapping, address)

Look up a copy of the maintained tags for one EVM vault address.

Classes

StrategyTag

Classify the investment strategies used by a vault.

StrategyTagMetadata

Human-readable presentation metadata for one strategy category.
class StrategyTag

Bases: str, enum.Enum

Classify the investment strategies used by a vault.

A vault may have more than one strategy tag. Tags describe its economic strategy, instrument, execution venue, or asset exposure rather than its smart-contract implementation, risk level, or current trading state. String values are stable identifiers suitable for persisted vault metadata and public data exports.

unknown = 'unknown'

Research established that the vault’s strategy is unknown. Example vault: none currently mapped.

directional_trading = 'directional_trading'

Takes directional exposure to one or more markets. Example vault: AllDeFi Quant Directional Strategy (GRVT).

directional_leverage = 'directional_leverage'

Maintains a fixed long or short exposure to one underlying asset using leverage. This is direct market exposure, not a trading signal, selection method, or other trade intelligence. Example vault: ADA 2x long (Lighter).

trend_following = 'trend_following'

Takes directional positions that follow sustained market movements. Example vault: Gen Wealth Algo (Hyperliquid).

discretionary_trading = 'discretionary_trading'

Uses trader judgement to select and manage positions. Example vault: Rogue Trader Discretionary (GRVT).

algorithmic_trading = 'algorithmic_trading'

Uses programmed rules to select, execute, or manage positions. Example vault: Silentist BALANCE (GRVT).

arbitrage = 'arbitrage'

Captures price differences between markets or related instruments. Example vault: Axis Origin (Upshift).

delta_neutral = 'delta_neutral'

Seeks to offset market exposure while capturing non-directional returns. Example vault: Grvt Liquidity Provider (GLP).

statistical_arbitrage = 'statistical_arbitrage'

Trades quantitatively identified pricing patterns. Example vault: SOL/BTC Neutral (Hyperliquid).

mean_reversion = 'mean_reversion'

Trades against price moves expected to return towards an average. Example vault: Growi HF (Hyperliquid).

grid_trading = 'grid_trading'

Places orders at predefined price intervals to capture market ranges. Example vault: AI Grid Trading Strategy (GRVT).

pair_trading = 'pair_trading'

Trades the relative price of two related assets. Example vault: pmalt (Hyperliquid).

fx = 'fx'

Trades foreign currencies. Example vault: Morini FXArbUSDTRY (Accountable).

funding_rate_arbitrage = 'funding_rate_arbitrage'

Captures funding-rate differences, commonly between perpetual futures markets. Example vault: Atoma Index (Atoma).

lending = 'lending'

Supplies assets to a lending market to earn interest. Example vault: Morpho Gauntlet USDC Prime (Morpho).

lending_optimisation = 'lending_optimisation'

Allocates supplied assets between lending opportunities to improve yield. Example vault: TAU Base USDC LO (IPOR Fusion).

lending_looping = 'lending_looping'

Borrows against supplied collateral to recursively increase lending exposure. Example vault: Prime HELOC Loop (IPOR Fusion).

market_making = 'market_making'

Provides executable liquidity to buyers and sellers. Example vault: KPK USDC LiquidLane (Symbiotic).

liquidity_provider = 'liquidity_provider'

Supplies capital to a venue or protocol as a liquidity provider. Example vault: Hyperliquidity Provider (HLP).

protocol_equity = 'protocol_equity'

Supplies loss-bearing protocol equity and participates in net income. Example vault: Frankencoin Shares (FCS).

market_making_amm = 'market_making_amm'

Actively makes markets by supplying liquidity through an automated market maker. Example vault: gTrade (Gains Network USDC).

market_making_clob = 'market_making_clob'

Provides liquidity through a central limit order book. Example vault: Pharos Market Maker (PMM) (GRVT).

multistrategy = 'multistrategy'

Combines multiple distinct investment strategies. Example vault: Axis Origin USDx (Upshift).

index = 'index'

Tracks a predefined market or asset index in an index-fund style. Example vault: Mantle Index Four (Securitize).

perpetual_futures = 'perpetual_futures'

Trades perpetual futures contracts. Example vault: Grvt Liquidity Provider (GLP).

options = 'options'

Uses options or option-like instruments as part of the strategy. Example vault: Staked Flying Tulip USD.

amm = 'amm'

Uses an automated market maker as the liquidity venue, regardless of whether the vault itself runs a market-making strategy. Example vault: gTrade (Gains Network USDC).

rwa = 'rwa'

Invests in real-world assets. Example vault: ynRWAx (YieldNest).

rwa_credit = 'rwa_credit'

Provides credit backed by real-world assets. Example vault: Balanced Bundle (GRVT).

rwa_lending = 'rwa_lending'

Lends against real-world assets. Example vault: ynRWAx (YieldNest).

rwa_royalties = 'rwa_royalties'

Invests in real-world royalty streams. Example vault: ALAR SailOut Royalty (Liquid Royalty).

money_market_fund = 'money_market_fund'

Invests in money-market instruments. Example vault: Spiko EU T-Bills Money Market Fund (Spiko).

venture_funding = 'venture_funding'

Invests in early-stage companies or projects in a venture-capital style. Example vault: BCAP (Securitize).

carry_trade = 'carry_trade'

Seeks return from the carry of an asset or position. Example vault: Staked USDe (Ethena).

__new__(value)
capitalize()

Return a capitalized version of the string.

More specifically, make the first character have upper case and the rest lower case.

casefold()

Return a version of the string suitable for caseless comparisons.

center(width, fillchar=' ', /)

Return a centered string of length width.

Padding is done using the specified fill character (default is a space).

count()

Return the number of non-overlapping occurrences of substring sub in string S[start:end].

Optional arguments start and end are interpreted as in slice notation.

encode(encoding='utf-8', errors='strict')

Encode the string using the codec registered for encoding.

encoding

The encoding in which to encode the string.

errors

The error handling scheme to use for encoding errors. The default is ‘strict’ meaning that encoding errors raise a UnicodeEncodeError. Other possible values are ‘ignore’, ‘replace’ and ‘xmlcharrefreplace’ as well as any other name registered with codecs.register_error that can handle UnicodeEncodeErrors.

endswith()

Return True if the string ends with the specified suffix, False otherwise.

suffix

A string or a tuple of strings to try.

start

Optional start position. Default: start of the string.

end

Optional stop position. Default: end of the string.

expandtabs(tabsize=8)

Return a copy where all tab characters are expanded using spaces.

If tabsize is not given, a tab size of 8 characters is assumed.

find()

Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].

Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.

format(*args, **kwargs)

Return a formatted version of the string, using substitutions from args and kwargs. The substitutions are identified by braces (‘{’ and ‘}’).

format_map(mapping, /)

Return a formatted version of the string, using substitutions from mapping. The substitutions are identified by braces (‘{’ and ‘}’).

isalnum()

Return True if the string is an alpha-numeric string, False otherwise.

A string is alpha-numeric if all characters in the string are alpha-numeric and there is at least one character in the string.

isalpha()

Return True if the string is an alphabetic string, False otherwise.

A string is alphabetic if all characters in the string are alphabetic and there is at least one character in the string.

isascii()

Return True if all characters in the string are ASCII, False otherwise.

ASCII characters have code points in the range U+0000-U+007F. Empty string is ASCII too.

isdecimal()

Return True if the string is a decimal string, False otherwise.

A string is a decimal string if all characters in the string are decimal and there is at least one character in the string.

isdigit()

Return True if the string is a digit string, False otherwise.

A string is a digit string if all characters in the string are digits and there is at least one character in the string.

isidentifier()

Return True if the string is a valid Python identifier, False otherwise.

Call keyword.iskeyword(s) to test whether string s is a reserved identifier, such as “def” or “class”.

islower()

Return True if the string is a lowercase string, False otherwise.

A string is lowercase if all cased characters in the string are lowercase and there is at least one cased character in the string.

isnumeric()

Return True if the string is a numeric string, False otherwise.

A string is numeric if all characters in the string are numeric and there is at least one character in the string.

isprintable()

Return True if all characters in the string are printable, False otherwise.

A character is printable if repr() may use it in its output.

isspace()

Return True if the string is a whitespace string, False otherwise.

A string is whitespace if all characters in the string are whitespace and there is at least one character in the string.

istitle()

Return True if the string is a title-cased string, False otherwise.

In a title-cased string, upper- and title-case characters may only follow uncased characters and lowercase characters only cased ones.

isupper()

Return True if the string is an uppercase string, False otherwise.

A string is uppercase if all cased characters in the string are uppercase and there is at least one cased character in the string.

join(iterable, /)

Concatenate any number of strings.

The string whose method is called is inserted in between each given string. The result is returned as a new string.

Example: ‘.’.join([‘ab’, ‘pq’, ‘rs’]) -> ‘ab.pq.rs’

ljust(width, fillchar=' ', /)

Return a left-justified string of length width.

Padding is done using the specified fill character (default is a space).

lower()

Return a copy of the string converted to lowercase.

lstrip(chars=None, /)

Return a copy of the string with leading whitespace removed.

If chars is given and not None, remove characters in chars instead.

static maketrans()

Return a translation table usable for str.translate().

If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters to Unicode ordinals, strings or None. Character keys will be then converted to ordinals. If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. If there is a third argument, it must be a string, whose characters will be mapped to None in the result.

partition(sep, /)

Partition the string into three parts using the given separator.

This will search for the separator in the string. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing the original string and two empty strings.

removeprefix(prefix, /)

Return a str with the given prefix string removed if present.

If the string starts with the prefix string, return string[len(prefix):]. Otherwise, return a copy of the original string.

removesuffix(suffix, /)

Return a str with the given suffix string removed if present.

If the string ends with the suffix string and that suffix is not empty, return string[:-len(suffix)]. Otherwise, return a copy of the original string.

replace(old, new, /, count=- 1)

Return a copy with all occurrences of substring old replaced by new.

count

Maximum number of occurrences to replace. -1 (the default value) means replace all occurrences.

If the optional argument count is given, only the first count occurrences are replaced.

rfind()

Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].

Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.

rindex()

Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].

Optional arguments start and end are interpreted as in slice notation. Raises ValueError when the substring is not found.

rjust(width, fillchar=' ', /)

Return a right-justified string of length width.

Padding is done using the specified fill character (default is a space).

rpartition(sep, /)

Partition the string into three parts using the given separator.

This will search for the separator in the string, starting at the end. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing two empty strings and the original string.

rsplit(sep=None, maxsplit=- 1)

Return a list of the substrings in the string, using sep as the separator string.

sep

The separator used to split the string.

When set to None (the default value), will split on any whitespace character (including n r t f and spaces) and will discard empty strings from the result.

maxsplit

Maximum number of splits. -1 (the default value) means no limit.

Splitting starts at the end of the string and works to the front.

rstrip(chars=None, /)

Return a copy of the string with trailing whitespace removed.

If chars is given and not None, remove characters in chars instead.

split(sep=None, maxsplit=- 1)

Return a list of the substrings in the string, using sep as the separator string.

sep

The separator used to split the string.

When set to None (the default value), will split on any whitespace character (including n r t f and spaces) and will discard empty strings from the result.

maxsplit

Maximum number of splits. -1 (the default value) means no limit.

Splitting starts at the front of the string and works to the end.

Note, str.split() is mainly useful for data that has been intentionally delimited. With natural text that includes punctuation, consider using the regular expression module.

splitlines(keepends=False)

Return a list of the lines in the string, breaking at line boundaries.

Line breaks are not included in the resulting list unless keepends is given and true.

startswith()

Return True if the string starts with the specified prefix, False otherwise.

prefix

A string or a tuple of strings to try.

start

Optional start position. Default: start of the string.

end

Optional stop position. Default: end of the string.

strip(chars=None, /)

Return a copy of the string with leading and trailing whitespace removed.

If chars is given and not None, remove characters in chars instead.

swapcase()

Convert uppercase characters to lowercase and lowercase characters to uppercase.

title()

Return a version of the string where each word is titlecased.

More specifically, words start with uppercased characters and all remaining cased characters have lower case.

translate(table, /)

Replace each character in the string using the given translation table.

table

Translation table, which must be a mapping of Unicode ordinals to Unicode ordinals, strings, or None.

The table must implement lookup/indexing via __getitem__, for instance a dictionary or list. If this operation raises LookupError, the character is left untouched. Characters mapped to None are deleted.

upper()

Return a copy of the string converted to uppercase.

zfill(width, /)

Pad a numeric string with zeros on the left, to fill a field of the given width.

The string is never truncated.

class StrategyTagMetadata

Bases: TypedDict

Human-readable presentation metadata for one strategy category.

label: str

Human-readable category label without Markdown links.

description: str

Short, plain-language summary of the investment activity.

__init__(*args, **kwargs)
__new__(**kwargs)
clear()

Remove all items from the dict.

copy()

Return a shallow copy of the dict.

fromkeys(value=None, /)

Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)

Return the value for key if key is in the dictionary, else default.

items()

Return a set-like object providing a view on the dict’s items.

keys()

Return a set-like object providing a view on the dict’s keys.

pop(k[, d]) → v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None.  Update D from mapping/iterable E and F.

If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values()

Return an object providing a view on the dict’s values.

STRATEGY_TAG_METADATA: dict[eth_defi.vault.strategy_tag.StrategyTag, eth_defi.vault.strategy_tag.StrategyTagMetadata] = {StrategyTag.algorithmic_trading: {'description': '[Software-driven rules](https://tradingstrategy.ai/glossary/algorithmic-trading) choose, execute and manage trades automatically.', 'label': 'Algorithmic trading'}, StrategyTag.amm: {'description': 'Trades or supplies liquidity through [pools where prices adjust automatically](https://tradingstrategy.ai/glossary/amm).', 'label': 'Automated market maker'}, StrategyTag.arbitrage: {'description': 'Buys where prices are lower and sells where they are higher.', 'label': 'Arbitrage'}, StrategyTag.carry_trade: {'description': 'Earns [recurring income from holding assets or balancing related positions](https://tradingstrategy.ai/glossary/carry-trade).', 'label': 'Carry trade'}, StrategyTag.delta_neutral: {'description': 'Balances [long and short exposure](https://tradingstrategy.ai/glossary/delta-neutral) to reduce the impact of market direction.', 'label': 'Delta neutral'}, StrategyTag.directional_leverage: {'description': 'Amplifies a fixed long or short position with borrowed capital.', 'label': 'Directional leverage'}, StrategyTag.directional_trading: {'description': 'Takes [long or short positions](https://tradingstrategy.ai/glossary/directional-strategy) to profit from rising or falling markets.', 'label': 'Directional trading'}, StrategyTag.discretionary_trading: {'description': 'A [human manager](https://tradingstrategy.ai/glossary/discretionary-investment-management) chooses and adjusts positions using judgement and market insight.', 'label': 'Discretionary trading'}, StrategyTag.funding_rate_arbitrage: {'description': 'Balances opposing futures positions to collect differences in recurring [funding payments](https://tradingstrategy.ai/glossary/funding-rate).', 'label': 'Funding-rate arbitrage'}, StrategyTag.fx: {'description': 'Trading related to foreign currencies.', 'label': 'FX'}, StrategyTag.grid_trading: {'description': 'Places staggered buy and sell orders across a price range.', 'label': 'Grid trading'}, StrategyTag.index: {'description': 'Tracks a defined basket of assets to mirror its overall market performance.', 'label': 'Index'}, StrategyTag.lending: {'description': 'Supplies assets to [lending markets](https://tradingstrategy.ai/glossary/lending-protocol) and earns interest from borrowers.', 'label': 'Lending'}, StrategyTag.lending_looping: {'description': 'Repeatedly [borrows and resupplies assets](https://tradingstrategy.ai/glossary/recursive-looping) to amplify lending returns and risk.', 'label': 'Lending looping'}, StrategyTag.lending_optimisation: {'description': 'Moves capital between lending markets to pursue the best available yield.', 'label': 'Lending optimisation'}, StrategyTag.liquidity_provider: {'description': '[Supplies capital that others can trade against](https://tradingstrategy.ai/glossary/liquidity-provider), earning fees or rewards.', 'label': 'Liquidity provider'}, StrategyTag.market_making: {'description': 'Continuously [offers to buy and sell](https://tradingstrategy.ai/glossary/market-making), earning from the spread between prices.', 'label': 'Market making'}, StrategyTag.market_making_amm: {'description': 'Supplies assets to automated trading pools and earns a share of trading fees.', 'label': 'AMM market making'}, StrategyTag.market_making_clob: {'description': 'Posts buy and sell orders on an order book to earn trading spreads.', 'label': 'Orderbook market making'}, StrategyTag.mean_reversion: {'description': 'Trades on the expectation that [prices will return towards their usual range](https://tradingstrategy.ai/glossary/mean-reversion).', 'label': 'Mean reversion'}, StrategyTag.money_market_fund: {'description': 'Holds short-term, highly liquid debt instruments for steady income.', 'label': 'Money-market fund'}, StrategyTag.multistrategy: {'description': 'Combines several investment approaches within one portfolio.', 'label': 'Multi-strategy'}, StrategyTag.options: {'description': 'Uses [options or option-like instruments](https://tradingstrategy.ai/glossary/options) to create or manage investment exposure.', 'label': 'Options'}, StrategyTag.pair_trading: {'description': 'Trades one related asset against another to profit from relative price changes.', 'label': 'Pair trading'}, StrategyTag.perpetual_futures: {'description': 'Trades [futures contracts without an expiry date](https://tradingstrategy.ai/glossary/perpetual-future), often using leverage.', 'label': 'Perpetual futures'}, StrategyTag.protocol_equity: {'description': 'Supplies loss-bearing capital to a protocol and participates in its net income and losses.', 'label': 'Protocol equity'}, StrategyTag.rwa: {'description': 'Invests in [tokenised claims on assets and income from outside crypto markets](https://tradingstrategy.ai/glossary/rwa).', 'label': 'Real-world assets'}, StrategyTag.rwa_credit: {'description': 'Finances loans secured by property, invoices or other real-world assets.', 'label': 'RWA credit'}, StrategyTag.rwa_lending: {'description': 'Lends money to real-world borrowers or against real-world collateral.', 'label': 'RWA lending'}, StrategyTag.rwa_royalties: {'description': 'Buys rights to income from music, media or other royalty streams.', 'label': 'RWA royalties'}, StrategyTag.statistical_arbitrage: {'description': 'Uses [statistical patterns](https://tradingstrategy.ai/glossary/statistical-arbitrage) to trade temporary pricing gaps between related markets.', 'label': 'Statistical arbitrage'}, StrategyTag.trend_following: {'description': 'Rides [sustained price movements](https://tradingstrategy.ai/glossary/trend-following), buying strength or selling weakness.', 'label': 'Trend following'}, StrategyTag.unknown: {'description': 'The investment approach is unknown.', 'label': 'Unknown strategy'}, StrategyTag.venture_funding: {'description': 'Backs early-stage companies or projects in pursuit of long-term growth.', 'label': 'Venture funding'}}

Public presentation labels and summaries for every strategy tag.

Descriptions are deliberately brief so API consumers can display them in a summary table without truncating the activity being described.

MORINI_CAPITAL_STRATEGY_TAGS = frozenset({StrategyTag.fx})

Morini Capital manages foreign-currency strategies across several vault protocols. These chain-scoped addresses were reviewed from the public vault metadata database on 2026-09-11.

CURATOR_STRATEGY_TAGS: dict[tuple[int, str], frozenset[eth_defi.vault.strategy_tag.StrategyTag]] = {(1, '0x2bf11d2e04bc40daa95c24b8b90ec4f5c57dd326'): frozenset({StrategyTag.fx}), (1, '0x58e0f0b81576f23c5f002d949b2bb11a5d2714d6'): frozenset({StrategyTag.fx}), (1, '0x810b29d043eb851ba4cf80b1b194ed5177e70958'): frozenset({StrategyTag.fx}), (1, '0x827ce7e8e35861d9ac7fe002755767b695a5594a'): frozenset({StrategyTag.fx}), (1, '0x99351baed3d8ab544ccb08af96a105910fda71e7'): frozenset({StrategyTag.fx}), (4663, '0x5b93dd3eb7fd224565498045f5e1a2ebda49e672'): frozenset({StrategyTag.fx})}

Chain-scoped classifications that follow a curator across vault protocols.

lookup_curator_strategy_tags(chain_id, address)

Look up a cross-protocol curator classification.

Curator classifications are chain-scoped because the same contract address can identify unrelated deployments on different EVM networks. Returning a fresh set prevents callers from mutating the maintained source mapping.

Parameters

  • chain_id (int) – EVM chain identifier.

  • address (str) – Vault contract or share-token address.

Returns

Curator-maintained strategy tags, or None when no mapping exists.

Return type

Optional[set[eth_defi.vault.strategy_tag.StrategyTag]]

lookup_strategy_tags(mapping, address)

Look up a copy of the maintained tags for one EVM vault address.

Maintained EVM mapping keys are plain lowercase strings rather than HexAddress constructor calls. Address inputs are normalised to lowercase before lookup. Returning a fresh set prevents scan consumers from mutating the protocol’s source mapping; an absent key remains None so missing information is not confused with a deliberately empty classification.

Mappings are intentionally keyed by address without a chain ID. An entry applies to every supported deployment at that address, so maintainers must confirm that same-address deployments use the same strategy before adding one. A genuinely chain-specific classification belongs in the protocol adapter’s hook instead of this shared address mapping.

Parameters
Returns

A mutable copy of the maintained tags, or None when no entry exists.

Return type

Optional[set[eth_defi.vault.strategy_tag.StrategyTag]]

combine_strategy_tags(defaults, mapping, address)

Combine default and address-specific tags for a native vault export.

Native integrations use protocol-specific identifiers, which may be EVM-style addresses or synthetic IDs. The helper normalises those identifiers and always returns a fresh set so callers cannot mutate either source collection.

Parameters
Returns

Combined mutable tag set.

Return type

set[eth_defi.vault.strategy_tag.StrategyTag]