@merkl/api 0.9.15

package/dist/src/utils/encodeCalls.js

@@ -0,0 +1,490 @@
+import { tokenType } from "@/engine/erc20SubTypeProcessors/helpers/tokenType";
+import { AaveInterface, AccountantWithRateProvidersInterface, AuraInterface, AuraOperatorInterface, BalancerGaugeInterface, BalancerPoolInterface, BalancerV3StablePoolInterface, BalancerVaultInterface, BeefyInterface, BunniV2HubInterface, BunniV2TokenInterface, CPMMGammaPoolMainInterface, CompoundInterface, CurveInterface, CurveLPTokenInterface, CurveStableSwapNGInterface, DefutureVaultInterface, ERC20Interface, ERC4626Interface, EnzymeInterface, EulerInterface, FactoryInterface, FluidInterface, FraxlendInterface, GearboxVaultInterface, HourglassERC20TBTInterface, HourglassVedaLockDepositorV2Interface, IonicInterface, LPManagerHelperInterface, LPManagerInterface, LayerBankInterface, LendleInterface, MaverickBPLensInterface, MetamorphoInterface, MoonwellInterface, OneInchStakingInterface, PendleInterface, PendleYTInterface, RadiantInterface, RfxDatastoreInterface, RswEthStrategyInterface, SpectraYTInterface, SturdyInterface, SymetricAmbientStrategyInterface, SyncSwapClassicPoolInterface, TorosInterface, UniswapV2PoolInterface, VePufferInterface, ZFStableLPINterface, } from "@sdk";
+export function createCall(target, key, type, metaData) {
+    switch (key) {
+        case "tokens":
+            return { allowFailure: true, callData: LPManagerInterface.encodeFunctionData("tokens", [metaData]), target };
+        case "getTokensCount":
+            return { allowFailure: true, callData: LPManagerInterface.encodeFunctionData("getTokensCount"), target };
+        case "getTotalValue":
+            return {
+                allowFailure: true,
+                callData: LPManagerHelperInterface.encodeFunctionData("getTotalValue", [metaData]),
+                target,
+            };
+        case "SY":
+            return { allowFailure: true, callData: PendleYTInterface.encodeFunctionData("SY"), target };
+        case "collateralContract":
+            return { allowFailure: true, callData: SturdyInterface.encodeFunctionData("collateralContract"), target };
+        case "pricePerShare":
+            return { allowFailure: true, callData: FraxlendInterface.encodeFunctionData("pricePerShare"), target };
+        case "lp_price":
+            switch (type) {
+                case tokenType.curve:
+                    return { allowFailure: true, callData: CurveInterface.encodeFunctionData("lp_price"), target };
+                case tokenType.curve_2:
+                case tokenType.maha:
+                    return { allowFailure: true, callData: CurveInterface.encodeFunctionData("get_virtual_price"), target };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}`);
+            }
+        case "coin0":
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [0]), target };
+        case "coin1":
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [1]), target };
+        case "coin2":
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [2]), target };
+        case "coins":
+            return { allowFailure: true, callData: CurveInterface.encodeFunctionData("coins", [metaData]), target };
+        case "N_COINS":
+            return { allowFailure: true, callData: CurveStableSwapNGInterface.encodeFunctionData("N_COINS"), target };
+        case "balances":
+            return {
+                allowFailure: true,
+                callData: CurveStableSwapNGInterface.encodeFunctionData("balances", [metaData]),
+                target,
+            };
+        case "operator":
+            return { allowFailure: true, callData: AuraInterface.encodeFunctionData("operator"), target };
+        case "pid":
+            return { allowFailure: true, callData: AuraInterface.encodeFunctionData("pid"), target };
+        case "lp_token":
+            switch (type) {
+                case tokenType.beraborrow_gauge:
+                case tokenType.beratrax_vault:
+                    return { allowFailure: true, callData: ERC4626Interface.encodeFunctionData("asset"), target };
+                default:
+                    return { allowFailure: true, callData: BalancerGaugeInterface.encodeFunctionData("lp_token"), target };
+            }
+        case "stakingToken":
+            return { allowFailure: true, callData: OneInchStakingInterface.encodeFunctionData("stakingToken"), target };
+        case "eVault":
+            return { allowFailure: true, callData: EulerInterface.encodeFunctionData("eVault"), target };
+        case "exchangeRate":
+            switch (type) {
+                case tokenType.pendle:
+                    return { allowFailure: true, callData: PendleInterface.encodeFunctionData("exchangeRate"), target };
+                case tokenType.ionic:
+                    return { allowFailure: true, callData: IonicInterface.encodeFunctionData("exchangeRateCurrent"), target };
+                case tokenType.moonwell:
+                case tokenType.venus:
+                case tokenType.reactor_fusion:
+                    return { allowFailure: true, callData: MoonwellInterface.encodeFunctionData("exchangeRateStored"), target };
+                case tokenType.layerbank:
+                    return { allowFailure: true, callData: LayerBankInterface.encodeFunctionData("exchangeRate"), target };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}`);
+            }
+        case "shortToken": {
+            return {
+                allowFailure: true,
+                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [metaData]),
+                target,
+            };
+        }
+        case "longToken": {
+            return {
+                allowFailure: true,
+                callData: RfxDatastoreInterface.encodeFunctionData("getAddress", [metaData]),
+                target,
+            };
+        }
+        case "asset":
+            return {
+                allowFailure: true,
+                callData: ERC4626Interface.encodeFunctionData("asset"),
+                target,
+            };
+        case "underlying":
+            switch (type) {
+                case tokenType.pendle:
+                case tokenType.pendleYT:
+                    return { allowFailure: true, callData: PendleInterface.encodeFunctionData("yieldToken"), target };
+                case tokenType.metamorpho:
+                    return { allowFailure: true, callData: MetamorphoInterface.encodeFunctionData("asset"), target };
+                case tokenType.fluid:
+                    return { allowFailure: true, callData: FluidInterface.encodeFunctionData("asset"), target };
+                case tokenType.euler_borrow:
+                case tokenType.maha:
+                case tokenType.euler_lend:
+                    return {
+                        allowFailure: true,
+                        callData: EulerInterface.encodeFunctionData("asset"),
+                        target,
+                    };
+                case tokenType.fraxlend:
+                case tokenType.sturdy_aggregator:
+                case tokenType.sturdy_silo:
+                    return { allowFailure: true, callData: FraxlendInterface.encodeFunctionData("asset"), target };
+                case tokenType.gearbox:
+                    return {
+                        allowFailure: true,
+                        callData: GearboxVaultInterface.encodeFunctionData("underlyingToken"),
+                        target,
+                    };
+                case tokenType.aura:
+                    return { allowFailure: true, callData: AuraInterface.encodeFunctionData("asset"), target };
+                case tokenType.ionic:
+                case tokenType.venus:
+                case tokenType.reactor_fusion:
+                    return { allowFailure: true, callData: IonicInterface.encodeFunctionData("underlying"), target };
+                case tokenType.layerbank:
+                    return { allowFailure: true, callData: LayerBankInterface.encodeFunctionData("underlying"), target };
+                case tokenType.moonwell:
+                    return { allowFailure: true, callData: MoonwellInterface.encodeFunctionData("underlying"), target };
+                case tokenType.radiant_lend:
+                case tokenType.radiant_borrow:
+                case tokenType.lendle_lending:
+                case tokenType.lendle_borrowing:
+                    return {
+                        allowFailure: true,
+                        callData: RadiantInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"),
+                        target,
+                    };
+                case tokenType.holdstation:
+                    return {
+                        allowFailure: true,
+                        callData: DefutureVaultInterface.encodeFunctionData("asset"),
+                        target,
+                    };
+                case tokenType.aave_lending:
+                case tokenType.aave_borrowing:
+                case tokenType.ironclad_lending:
+                case tokenType.ironclad_borrowing:
+                case tokenType.zerolend_lending:
+                case tokenType.zerolend_borrowing:
+                case tokenType.avalon_lending:
+                case tokenType.avalon_borrowing:
+                case tokenType.superlend_lending:
+                case tokenType.superlend_borrowing:
+                case tokenType.takotako_lending:
+                case tokenType.takotako_borrowing:
+                case tokenType.yei_borrowing:
+                case tokenType.yei_lending:
+                case tokenType.vicuna_borrowing:
+                case tokenType.vicuna_lending:
+                    return { allowFailure: true, callData: AaveInterface.encodeFunctionData("UNDERLYING_ASSET_ADDRESS"), target };
+                case tokenType.hourglass:
+                    return {
+                        allowFailure: true,
+                        callData: HourglassVedaLockDepositorV2Interface.encodeFunctionData("getUnderlying"),
+                        target,
+                    };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}, or unknown type ${type}`);
+            }
+        case "calcNetShareValue":
+            return {
+                allowFailure: true,
+                callData: EnzymeInterface.encodeFunctionData("calcNetShareValue", [metaData]),
+                target,
+            };
+        case "getPricePerFullShare":
+            return { allowFailure: true, callData: BeefyInterface.encodeFunctionData("getPricePerFullShare"), target };
+        case "token0":
+            return { allowFailure: true, callData: UniswapV2PoolInterface.encodeFunctionData("token0"), target };
+        case "token1":
+            return { allowFailure: true, callData: UniswapV2PoolInterface.encodeFunctionData("token1"), target };
+        case "baseToken":
+            return { allowFailure: true, callData: CompoundInterface.encodeFunctionData("baseToken"), target };
+        case "factory":
+            return { allowFailure: true, callData: FactoryInterface.encodeFunctionData("factory"), target };
+        case "getAssetPrice":
+            return { allowFailure: true, callData: RadiantInterface.encodeFunctionData("getAssetPrice"), target };
+        case "want":
+            return { allowFailure: true, callData: BeefyInterface.encodeFunctionData("want"), target };
+        case "symbol":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("symbol"),
+                target,
+            };
+        case "name":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("name"),
+                target,
+            };
+        case "decimals":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("decimals"),
+                target,
+            };
+        case "totalSupply":
+            switch (type) {
+                case tokenType.lendle_lending:
+                case tokenType.lendle_borrowing:
+                    return {
+                        allowFailure: true,
+                        callData: LendleInterface.encodeFunctionData("scaledTotalSupply"),
+                        target,
+                    };
+                default:
+                    return {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("totalSupply"),
+                        target,
+                    };
+            }
+        case "balanceOf":
+            return {
+                allowFailure: true,
+                callData: ERC20Interface.encodeFunctionData("balanceOf", [metaData]),
+                target,
+            };
+        case "getPoolId":
+            return {
+                allowFailure: true,
+                callData: BalancerPoolInterface.encodeFunctionData("getPoolId"),
+                target,
+            };
+        case "getVault":
+            return {
+                allowFailure: true,
+                callData: BalancerPoolInterface.encodeFunctionData("getVault"),
+                target,
+            };
+        case "poolInfo":
+            return {
+                allowFailure: true,
+                callData: AuraOperatorInterface.encodeFunctionData("poolInfo", [metaData]),
+                target,
+            };
+        case "staker":
+            return { allowFailure: true, callData: AuraOperatorInterface.encodeFunctionData("staker"), target };
+        case "getPoolTokens":
+            return {
+                allowFailure: true,
+                callData: BalancerVaultInterface.encodeFunctionData("getPoolTokens", [metaData]),
+                target,
+            };
+        case "convertToAssets":
+            return {
+                allowFailure: true,
+                callData: FluidInterface.encodeFunctionData("convertToAssets", [metaData]),
+                target,
+            };
+        case "tokenPrice":
+            return {
+                allowFailure: true,
+                callData: TorosInterface.encodeFunctionData("tokenPrice"),
+                target,
+            };
+        case "totalAssets":
+            switch (type) {
+                case tokenType.anglesLiquid:
+                case tokenType.cian:
+                case tokenType.rfx_slv:
+                case tokenType.metamorpho:
+                case tokenType.beratrax_vault:
+                case tokenType.beraborrow_gauge:
+                    return {
+                        allowFailure: true,
+                        callData: ERC4626Interface.encodeFunctionData("totalAssets"),
+                        target,
+                    };
+                case tokenType.concrete:
+                    return {
+                        allowFailure: true,
+                        callData: ERC4626Interface.encodeFunctionData("totalAssets"),
+                        target,
+                    };
+                case tokenType.euler_borrow:
+                    return {
+                        allowFailure: true,
+                        callData: EulerInterface.encodeFunctionData("totalBorrows"),
+                        target,
+                    };
+                case tokenType.euler_lend:
+                    return {
+                        allowFailure: true,
+                        callData: EulerInterface.encodeFunctionData("totalAssets"),
+                        target,
+                    };
+                case tokenType.gearbox:
+                    return {
+                        allowFailure: true,
+                        callData: GearboxVaultInterface.encodeFunctionData("totalAssets"),
+                        target,
+                    };
+                case tokenType.compound:
+                    return {
+                        allowFailure: true,
+                        callData: CompoundInterface.encodeFunctionData("totalBorrow"),
+                        target: target,
+                    };
+                default:
+                    throw new Error(`Need tokenType for this key ${key}, or unknown type ${type}`);
+            }
+        case "readTokens0":
+            return {
+                allowFailure: true,
+                callData: PendleInterface.encodeFunctionData("readTokens"),
+                target: target,
+            };
+        case "readTokens2":
+            return {
+                allowFailure: true,
+                callData: PendleInterface.encodeFunctionData("readTokens"),
+                target: target,
+            };
+        case "boostedPositionInformation":
+            return {
+                allowFailure: true,
+                callData: MaverickBPLensInterface.encodeFunctionData("boostedPositionInformation", [metaData]),
+                target: target,
+            };
+        case "minter":
+            switch (type) {
+                case tokenType.spectra_lpt:
+                    return {
+                        allowFailure: true,
+                        callData: CurveLPTokenInterface.encodeFunctionData("minter"),
+                        target: target,
+                    };
+                default:
+                    return {
+                        allowFailure: true,
+                        callData: ZFStableLPINterface.encodeFunctionData("minter"),
+                        target: target,
+                    };
+            }
+        case "principalToken":
+            return {
+                allowFailure: true,
+                callData: SpectraYTInterface.encodeFunctionData("getPT"),
+                target: target,
+            };
+        case "getTokenAddresses":
+            switch (type) {
+                case tokenType.tempestStaking: {
+                    return {
+                        allowFailure: true,
+                        callData: RswEthStrategyInterface.encodeFunctionData("getTokenAddresses"),
+                        target: target,
+                    };
+                }
+                default:
+                    return {
+                        allowFailure: true,
+                        callData: SymetricAmbientStrategyInterface.encodeFunctionData("getTokenAddresses"),
+                        target: target,
+                    };
+            }
+        case "getPositions":
+            switch (type) {
+                case tokenType.tempestStaking: {
+                    return {
+                        allowFailure: true,
+                        callData: RswEthStrategyInterface.encodeFunctionData("getPositions"),
+                        target: target,
+                    };
+                }
+                default:
+                    return {
+                        allowFailure: true,
+                        callData: SymetricAmbientStrategyInterface.encodeFunctionData("getPositions"),
+                        target: target,
+                    };
+            }
+        case "tvl":
+            return {
+                allowFailure: true,
+                callData: DefutureVaultInterface.encodeFunctionData("tvl"),
+                target: target,
+            };
+        case "lockNFT":
+            return {
+                allowFailure: true,
+                callData: VePufferInterface.encodeFunctionData("lockNFT"),
+                target: target,
+            };
+        case "eip712DomainName":
+            return {
+                allowFailure: true,
+                callData: MetamorphoInterface.encodeFunctionData("eip712Domain"),
+                target: target,
+            };
+        case "getRate":
+            return {
+                allowFailure: true,
+                callData: AccountantWithRateProvidersInterface.encodeFunctionData("getRate"),
+                target: target,
+            };
+        case "base":
+            return {
+                allowFailure: true,
+                callData: AccountantWithRateProvidersInterface.encodeFunctionData("base"),
+                target: target,
+            };
+        case "tokensRaw":
+            return {
+                allowFailure: true,
+                callData: CPMMGammaPoolMainInterface.encodeFunctionData("tokens"),
+                target: target,
+            };
+        case "tokenBalances":
+            return {
+                allowFailure: true,
+                callData: CPMMGammaPoolMainInterface.encodeFunctionData("getLatestCFMMBalances"),
+                target: target,
+            };
+        case "getReserves":
+            return {
+                allowFailure: true,
+                callData: UniswapV2PoolInterface.encodeFunctionData("getReserves"),
+                target: target,
+            };
+        case "reserve0":
+            return {
+                allowFailure: true,
+                callData: SyncSwapClassicPoolInterface.encodeFunctionData("reserve0"),
+                target: target,
+            };
+        case "reserve1":
+            return {
+                allowFailure: true,
+                callData: SyncSwapClassicPoolInterface.encodeFunctionData("reserve1"),
+                target: target,
+            };
+        case "depositor":
+            return {
+                allowFailure: true,
+                callData: HourglassERC20TBTInterface.encodeFunctionData("depositor"),
+                target: target,
+            };
+        case "getTokens":
+            return {
+                allowFailure: true,
+                callData: BalancerV3StablePoolInterface.encodeFunctionData("getTokens"),
+                target: target,
+            };
+        case "getTokenInfo":
+            return {
+                allowFailure: true,
+                callData: BalancerV3StablePoolInterface.encodeFunctionData("getTokenInfo"),
+                target: target,
+            };
+        case "hub":
+            return {
+                allowFailure: true,
+                callData: BunniV2TokenInterface.encodeFunctionData("hub"),
+                target: target,
+            };
+        case "poolKey":
+            return {
+                allowFailure: true,
+                callData: BunniV2TokenInterface.encodeFunctionData("poolKey"),
+                target: target,
+            };
+        case "poolState":
+            return {
+                allowFailure: true,
+                callData: BunniV2HubInterface.encodeFunctionData("poolState", [metaData]),
+                target: target,
+            };
+        default:
+            throw new Error(`Unknown key ${key}`);
+    }
+}

package/dist/src/utils/error.d.ts

@@ -0,0 +1,60 @@
+import { HttpError } from "@/errors";
+import { type ChainId } from "@sdk";
+import type Elysia from "elysia";
+import { ValidationError } from "elysia";
+export declare class InvalidParameter extends Error {
+    message: string;
+    constructor(message: string);
+}
+export declare class UnsupportedNetwork extends Error {
+    chainId: ChainId;
+    constructor(chainId: ChainId);
+}
+export declare class OpportunityNotFound extends Error {
+    mainParameter: string;
+    chainId: ChainId;
+    constructor(mainParameter: string, chainId: ChainId);
+}
+export declare class CannotParseOpportunity extends Error {
+    campaignId: string;
+    chainId: ChainId;
+    type: number;
+    constructor(campaignId: string, chainId: ChainId, type: number);
+}
+export declare class MerkleRootNotFound extends Error {
+    chainId: ChainId;
+    constructor(chainId: ChainId);
+}
+export declare class InvalidCacheCall extends Error {
+    message: string;
+    constructor(message: string);
+}
+export declare const errorHandler: (canLog?: boolean) => (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {
+        readonly InvalidParameter: InvalidParameter;
+        readonly UnsupportedNetwork: UnsupportedNetwork;
+        readonly OpportunityNotFound: OpportunityNotFound;
+        readonly MerkleRootNotFound: MerkleRootNotFound;
+        readonly ValidationError: ValidationError;
+        readonly InvalidCacheCall: InvalidCacheCall;
+        readonly HttpError: HttpError;
+    };
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/utils/error.js

@@ -0,0 +1,102 @@
+import { HttpError } from "@/errors";
+import { NETWORK_LABELS } from "@sdk";
+import { ValidationError } from "elysia";
+export class InvalidParameter extends Error {
+    message;
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = "INVALID_PARAMETER";
+    }
+}
+export class UnsupportedNetwork extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`API for Merkl products by Angle Labs does not support (yet) network ${chainId}`);
+        this.chainId = chainId;
+        this.name = "UNSUPPORTED_NETWORK";
+    }
+}
+export class OpportunityNotFound extends Error {
+    mainParameter;
+    chainId;
+    constructor(mainParameter, chainId) {
+        super(`No campaigns found for mainParameter ${mainParameter} on chain ${NETWORK_LABELS[chainId]}`);
+        this.mainParameter = mainParameter;
+        this.chainId = chainId;
+        this.name = "OPPORTUNITY_NOT_FOUND";
+    }
+}
+export class CannotParseOpportunity extends Error {
+    campaignId;
+    chainId;
+    type;
+    constructor(campaignId, chainId, type) {
+        super(`Cannot parse opportunity from campaign ${campaignId} of type ${type} on chain ${NETWORK_LABELS[chainId]}`);
+        this.campaignId = campaignId;
+        this.chainId = chainId;
+        this.type = type;
+        this.name = "OPPORTUNITY_CANNOT_BE_PARSED";
+    }
+}
+export class MerkleRootNotFound extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`No Merkl root found for network ${NETWORK_LABELS[chainId]} (${chainId})`);
+        this.chainId = chainId;
+        this.name = "MERKLE_ROOT_NOT_FOUND";
+    }
+}
+export class InvalidCacheCall extends Error {
+    message;
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = "INVALID_CACHE_CALL";
+    }
+}
+export const errorHandler = (canLog = true) => {
+    return (app) => app
+        .error({
+        InvalidParameter,
+        UnsupportedNetwork,
+        OpportunityNotFound,
+        MerkleRootNotFound,
+        ValidationError,
+        InvalidCacheCall,
+        HttpError,
+    })
+        .onError(({ error, path, query, code, set, ...all }) => {
+        const response = (status, log = true, overrides) => {
+            if (canLog && log)
+                console.error(`[${path}](${JSON.stringify(query) ?? ""}): ${error.message} : ${error.stack}`);
+            return new Response(JSON.stringify(Object.assign({
+                error: error.name !== "Error" ? error.name : code,
+                message: error.message,
+            }, overrides ?? {})), {
+                status,
+            });
+        };
+        switch (code) {
+            case "InvalidParameter":
+            case "InvalidCacheCall":
+                return response(400, false);
+            case "NOT_FOUND":
+                return response(404, false, { message: `${path} does not exist` });
+            case "UnsupportedNetwork":
+            case "OpportunityNotFound":
+            case "MerkleRootNotFound":
+                return response(404, false);
+            case "VALIDATION": {
+                const errorObj = JSON.parse(error.message);
+                const property = (errorObj.property ?? "").replaceAll("/", "");
+                return response(400, false, {
+                    message: errorObj.summary,
+                    found: (property === "" ? errorObj.found : errorObj.found?.[property]) ?? "undefined",
+                });
+            }
+            default:
+                return response(500);
+        }
+    });
+};

package/dist/src/utils/execute.d.ts

@@ -0,0 +1,22 @@
+import type { MultiCallDataType } from "../types";
+/**
+ * Types
+ */
+type CachedResult<T> = {
+    cached: true;
+    result: T;
+};
+type ComponentReturnType<T> = Promise<CachedResult<T> | UncachedResult<T>>;
+export type UncachedResult<T> = {
+    cached: false;
+    call: {
+        callData: MultiCallDataType;
+        reducer: (result: string[]) => Promise<T>;
+        handler: () => void;
+    };
+};
+/**
+ * Functions
+ */
+export declare function executeSimple<T>(chainId: number, componentCall: ComponentReturnType<T>): Promise<T>;
+export {};