@drift-labs/sdk 0.2.0-master.30 → 0.2.0-master.32

package/lib/admin.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="bn.js" />
 import { PublicKey, TransactionSignature } from '@solana/web3.js';
-import { FeeStructure, OracleGuardRails, OracleSource } from './types';
+import { FeeStructure, OracleGuardRails, OracleSource, ExchangeStatus, MarketStatus, ContractTier, AssetTier } from './types';
 import { BN } from '@project-serum/anchor';
 import { ClearingHouse } from './clearingHouse';
 export declare class Admin extends ClearingHouse {
-    initialize(usdcMint: PublicKey, adminControlsPrices: boolean): Promise<[TransactionSignature]>;
-    initializeSpotMarket(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN): Promise<TransactionSignature>;
+    initialize(usdcMint: PublicKey, _adminControlsPrices: boolean): Promise<[TransactionSignature]>;
+    initializeSpotMarket(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN, activeStatus?: boolean): Promise<TransactionSignature>;
     initializeSerumFulfillmentConfig(marketIndex: number, serumMarket: PublicKey, serumProgram: PublicKey): Promise<TransactionSignature>;
-    initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN): Promise<TransactionSignature>;
+    initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN, activeStatus?: boolean): Promise<TransactionSignature>;
     moveAmmPrice(marketIndex: number, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
     updateK(sqrtK: BN, marketIndex: number): Promise<TransactionSignature>;
     updateConcentrationScale(marketIndex: number, concentrationScale: BN): Promise<TransactionSignature>;
@@ -33,6 +33,7 @@ export declare class Admin extends ClearingHouse {
     updateWithdrawGuardThreshold(marketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
     updateSpotMarketIfFactor(marketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
     updateSpotMarketRevenueSettlePeriod(marketIndex: number, revenueSettlePeriod: BN): Promise<TransactionSignature>;
+    updateSpotMarketMaxTokenDeposits(marketIndex: number, maxTokenDeposits: BN): Promise<TransactionSignature>;
     updateInsuranceWithdrawEscrowPeriod(marketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
     updateLpCooldownTime(marketIndex: number, cooldownTime: BN): Promise<TransactionSignature>;
     updateMarketOracle(marketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
@@ -42,9 +43,12 @@ export declare class Admin extends ClearingHouse {
     updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
     updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
     updateMaxDeposit(maxDeposit: BN): Promise<TransactionSignature>;
-    updateFundingPaused(fundingPaused: boolean): Promise<TransactionSignature>;
-    updateExchangePaused(exchangePaused: boolean): Promise<TransactionSignature>;
-    disableAdminControlsPrices(): Promise<TransactionSignature>;
+    updateSpotMarketMarginWeights(spotMarketIndex: number, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN): Promise<TransactionSignature>;
+    updateSpotMarketAssetTier(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionSignature>;
+    updateSpotMarketStatus(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;
+    updatePerpMarketStatus(perpMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;
+    updatePerpMarketContractTier(perpMarketIndex: number, contractTier: ContractTier): Promise<TransactionSignature>;
+    updateExchangeStatus(exchangeStatus: ExchangeStatus): Promise<TransactionSignature>;
     updatePerpAuctionDuration(minDuration: BN | number): Promise<TransactionSignature>;
     updateSpotAuctionDuration(defaultAuctionDuration: number): Promise<TransactionSignature>;
     updateMaxBaseAssetAmountRatio(marketIndex: number, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;

package/lib/admin.js

@@ -36,13 +36,13 @@ const numericConstants_1 = require("./constants/numericConstants");
 const trade_1 = require("./math/trade");
 const amm_1 = require("./math/amm");
 class Admin extends clearingHouse_1.ClearingHouse {
-    async initialize(usdcMint, adminControlsPrices) {
+    async initialize(usdcMint, _adminControlsPrices) {
         const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(await this.getStatePublicKey());
         if (stateAccountRPCResponse.value !== null) {
             throw new Error('Clearing house already initialized');
         }
         const [clearingHouseStatePublicKey] = await (0, pda_1.getClearingHouseStateAccountPublicKeyAndNonce)(this.program.programId);
-        const initializeTx = await this.program.transaction.initialize(adminControlsPrices, {
+        const initializeTx = await this.program.transaction.initialize({
             accounts: {
                 admin: this.wallet.publicKey,
                 state: clearingHouseStatePublicKey,
@@ -56,12 +56,12 @@ class Admin extends clearingHouse_1.ClearingHouse {
         const { txSig: initializeTxSig } = await this.txSender.send(initializeTx, [], this.opts);
         return [initializeTxSig];
     }
-    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO) {
+    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0), liquidationFee = numericConstants_1.ZERO, activeStatus = true) {
         const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
         const spotMarket = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex);
         const spotMarketVault = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, spotMarketIndex);
         const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, spotMarketIndex);
-        const initializeTx = await this.program.transaction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, {
+        const initializeTx = await this.program.transaction.initializeSpotMarket(optimalUtilization, optimalRate, maxRate, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidationFee, activeStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
@@ -103,9 +103,9 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO) {
+    async initializeMarket(priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidationFee = numericConstants_1.ZERO, activeStatus = true) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, this.getStateAccount().numberOfMarkets);
-        const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, {
+        const initializeMarketTx = await this.program.transaction.initializeMarket(baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, marginRatioInitial, marginRatioMaintenance, liquidationFee, activeStatus, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 admin: this.wallet.publicKey,
@@ -366,6 +366,15 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateSpotMarketMaxTokenDeposits(marketIndex, maxTokenDeposits) {
+        return await this.program.rpc.updateSpotMarketMaxTokenDeposits(maxTokenDeposits, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex),
+            },
+        });
+    }
     async updateInsuranceWithdrawEscrowPeriod(marketIndex, insuranceWithdrawEscrowPeriod) {
         return await this.program.rpc.updateInsuranceWithdrawEscrowPeriod(insuranceWithdrawEscrowPeriod, {
             accounts: {
@@ -444,24 +453,53 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async updateFundingPaused(fundingPaused) {
-        return await this.program.rpc.updateFundingPaused(fundingPaused, {
+    async updateSpotMarketMarginWeights(spotMarketIndex, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = new anchor_1.BN(0)) {
+        return await this.program.rpc.updateSpotMarketMarginWeights(initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketAssetTier(spotMarketIndex, assetTier) {
+        return await this.program.rpc.updateSpotMarketAssetTier(assetTier, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updateSpotMarketStatus(spotMarketIndex, marketStatus) {
+        return await this.program.rpc.updateSpotMarketStatus(marketStatus, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
+    async updatePerpMarketStatus(perpMarketIndex, marketStatus) {
+        return await this.program.rpc.updatePerpMarketStatus(marketStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async updateExchangePaused(exchangePaused) {
-        return await this.program.rpc.updateExchangePaused(exchangePaused, {
+    async updatePerpMarketContractTier(perpMarketIndex, contractTier) {
+        return await this.program.rpc.updatePerpMarketContractTier(contractTier, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
+                market: await (0, pda_1.getMarketPublicKey)(this.program.programId, perpMarketIndex),
             },
         });
     }
-    async disableAdminControlsPrices() {
-        return await this.program.rpc.disableAdminControlsPrices({
+    async updateExchangeStatus(exchangeStatus) {
+        return await this.program.rpc.updateExchangeStatus(exchangeStatus, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),

package/lib/clearingHouse.d.ts

@@ -14,6 +14,14 @@ import { ClearingHouseConfig } from './clearingHouseConfig';
 import { ClearingHouseUser } from './clearingHouseUser';
 import { ClearingHouseUserAccountSubscriptionConfig } from './clearingHouseUserConfig';
 import { ClearingHouseUserStats } from './clearingHouseUserStats';
+declare type RemainingAccountParams = {
+    userAccounts: UserAccount[];
+    writablePerpMarketIndexes?: number[];
+    writableSpotMarketIndexes?: number[];
+    readablePerpMarketIndex?: number;
+    readableSpotMarketIndex?: number;
+    useMarketLastSlotCache?: boolean;
+};
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -75,6 +83,7 @@ export declare class ClearingHouse {
     updateUserCustomMarginRatio(marginRatio: number, userId?: number): Promise<TransactionSignature>;
     updateUserDelegate(delegate: PublicKey, userId?: number): Promise<TransactionSignature>;
     getUserAccountsForDelegate(delegate: PublicKey): Promise<UserAccount[]>;
+    deleteUser(userId?: number): Promise<TransactionSignature>;
     getUser(userId?: number): ClearingHouseUser;
     getUsers(): ClearingHouseUser[];
     getUserStats(): ClearingHouseUserStats;
@@ -85,13 +94,13 @@ export declare class ClearingHouse {
     getUserAccountAndSlot(userId?: number): DataAndSlot<UserAccount> | undefined;
     getSpotPosition(marketIndex: number): SpotPosition | undefined;
     getQuoteAssetTokenAmount(): BN;
-    getRemainingAccounts(params: {
-        writablePerpMarketIndex?: number;
-        writableSpotMarketIndex?: number;
-        readablePerpMarketIndex?: number;
-        readableSpotMarketIndex?: number;
-    }): AccountMeta[];
-    getOrder(orderId: BN | number): Order | undefined;
+    getRemainingAccounts(params: RemainingAccountParams): AccountMeta[];
+    getRemainingAccountMapsForUsers(userAccounts: UserAccount[]): {
+        oracleAccountMap: Map<string, AccountMeta>;
+        spotMarketAccountMap: Map<number, AccountMeta>;
+        perpMarketAccountMap: Map<number, AccountMeta>;
+    };
+    getOrder(orderId: number): Order | undefined;
     getOrderByUserId(userOrderId: number): Order | undefined;
     deposit(amount: BN, marketIndex: number, collateralAccountPublicKey: PublicKey, userId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
     getDepositInstruction(amount: BN, marketIndex: number, userTokenAccount: PublicKey, userId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
@@ -142,11 +151,11 @@ export declare class ClearingHouse {
     getUpdateAMMsIx(marketIndexes: number[]): Promise<TransactionInstruction>;
     settleExpiredMarket(marketIndex: number): Promise<TransactionSignature>;
     getSettleExpiredMarketIx(marketIndex: number): Promise<TransactionInstruction>;
-    cancelOrder(orderId?: BN): Promise<TransactionSignature>;
-    getCancelOrderIx(orderId?: BN): Promise<TransactionInstruction>;
+    cancelOrder(orderId?: number): Promise<TransactionSignature>;
+    getCancelOrderIx(orderId?: number): Promise<TransactionInstruction>;
     cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
     getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
-    fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
+    fillOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
     getFillOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     placeSpotOrder(orderParams: OptionalOrderParams): Promise<TransactionSignature>;
     getPlaceSpotOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
@@ -154,8 +163,6 @@ export declare class ClearingHouse {
     getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
-    triggerSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order): Promise<TransactionSignature>;
-    getTriggerSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
     placeAndTake(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
     getPlaceAndTakeIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     placeAndMake(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionSignature>;
@@ -176,25 +183,20 @@ export declare class ClearingHouse {
     getSettleExpiredPositionIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
     liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN): Promise<TransactionSignature>;
     getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN): Promise<TransactionInstruction>;
-    liquidateBorrow(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
-    getLiquidateBorrowIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
+    liquidateSpot(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
+    getLiquidateSpotIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
     liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionSignature>;
     getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN): Promise<TransactionInstruction>;
     liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN): Promise<TransactionSignature>;
     getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN): Promise<TransactionInstruction>;
     resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
     getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
-    resolveBorrowBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
-    getResolveBorrowBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
-    getRemainingAccountsWithCounterparty(params: {
-        counterPartyUserAccount: UserAccount;
-        writablePerpMarketIndex?: number;
-        writableSpotMarketIndexes?: number[];
-    }): AccountMeta[];
+    resolveSpotBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionSignature>;
+    getResolveSpotBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
     updateFundingRate(oracle: PublicKey, marketIndex: number): Promise<TransactionSignature>;
     getUpdateFundingRateIx(oracle: PublicKey, marketIndex: number): Promise<TransactionInstruction>;
-    settleFundingPayment(userAccount: PublicKey): Promise<TransactionSignature>;
-    getSettleFundingPaymentIx(userAccount: PublicKey): Promise<TransactionInstruction>;
+    settleFundingPayment(userAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    getSettleFundingPaymentIx(userAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
     triggerEvent(eventName: keyof ClearingHouseAccountEvents, data?: any): void;
     getOracleDataForMarket(marketIndex: number): OraclePriceData;
     getOracleDataForSpotMarket(marketIndex: number): OraclePriceData;
@@ -208,3 +210,4 @@ export declare class ClearingHouse {
     resolvePerpPnlDeficit(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionSignature>;
     getResolvePerpPnlDeficitIx(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionInstruction>;
 }
+export {};