@mirage-protocol/sdk
Version:
Typescript library for interacting with Mirage Protocol move contracts
1,301 lines (1,281 loc) • 214 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
// src/index.ts
var src_exports = {};
__export(src_exports, {
Deployment: () => Deployment,
EXCHANGE_RATE_PRECISION: () => EXCHANGE_RATE_PRECISION,
FEE_PRECISION: () => FEE_PRECISION,
GetCollectionsByOwnerDocument: () => GetCollectionsByOwnerDocument,
GetCurrentOwnerBalancesDocument: () => GetCurrentOwnerBalancesDocument,
GetTokenIdsFromCollectionByOwnerDocument: () => GetTokenIdsFromCollectionByOwnerDocument,
GetTokenIdsFromCollectionsByOwnerDocument: () => GetTokenIdsFromCollectionsByOwnerDocument,
INTEREST_PRECISION: () => INTEREST_PRECISION,
LimitOrder: () => LimitOrder,
MIN_TRIGGER_PAYMENT: () => MIN_TRIGGER_PAYMENT,
Market: () => Market,
MirageAsset: () => MirageAsset,
MirageClient: () => MirageClient,
MirageClientBase: () => MirageClientBase,
MirageConfig: () => MirageConfig,
MoveModules: () => MoveModules,
OrderType: () => OrderType,
PERCENT_PRECISION: () => PERCENT_PRECISION,
PRECISION_8: () => PRECISION_8,
Position: () => Position,
PositionSide: () => PositionSide,
RATE_PRECISION: () => RATE_PRECISION,
Rebase: () => Rebase,
SECONDS_PER_YEAR: () => SECONDS_PER_YEAR,
TpSl: () => TpSl,
U64_MAX: () => U64_MAX,
UserProfile: () => UserProfile,
UserProfileCollection: () => UserProfileCollection,
UserReferral: () => UserReferral,
Vault: () => Vault,
VaultCollection: () => VaultCollection,
ZERO: () => ZERO,
allMarketAddressesView: () => allMarketAddressesView,
allMirageAssetsView: () => allMirageAssetsView,
allOraclesView: () => allOraclesView,
allOwnedVaultAddressesQuery: () => allOwnedVaultAddressesQuery,
allPositionByOwnerQuery: () => allPositionByOwnerQuery,
allPositionInfoView: () => allPositionInfoView,
allVaultCollectionsView: () => allVaultCollectionsView,
availableMarginView: () => availableMarginView,
borrowOracleView: () => borrowOracleView,
borrowTokenView: () => borrowTokenView,
buildMirageConfig: () => buildMirageConfig,
calculateVaultHealth: () => calculateVaultHealth,
collateralOracleView: () => collateralOracleView,
collateralTokenView: () => collateralTokenView,
createAccrueInterestPayload: () => createAccrueInterestPayload,
createAddCollateralAndBorrowPayload: () => createAddCollateralAndBorrowPayload,
createAddCollateralAndRepayDebt: () => createAddCollateralAndRepayDebt,
createAddCollateralPayload: () => createAddCollateralPayload,
createAddCustomReferralCodePayload: () => createAddCustomReferralCodePayload,
createAddVipReferralRatePayload: () => createAddVipReferralRatePayload,
createAndOpenPositionPayload: () => createAndOpenPositionPayload,
createAndOpenPositionWithTpslPayload: () => createAndOpenPositionWithTpslPayload,
createBorrowPayload: () => createBorrowPayload,
createCancelLimitOrderPayload: () => createCancelLimitOrderPayload,
createCancelTpslPayload: () => createCancelTpslPayload,
createClaimAirdropPayload: () => createClaimAirdropPayload,
createCleanupLimitOrderPayload: () => createCleanupLimitOrderPayload,
createCleanupTpslPayload: () => createCleanupTpslPayload,
createCloseAllPositionsPayload: () => createCloseAllPositionsPayload,
createClosePositionPayload: () => createClosePositionPayload,
createDecreaseLimitOrderMarginPayload: () => createDecreaseLimitOrderMarginPayload,
createDecreaseMarginPayload: () => createDecreaseMarginPayload,
createDecreasePositionSizePayload: () => createDecreasePositionSizePayload,
createDecreaseSizeAndDecreaseMarginPayload: () => createDecreaseSizeAndDecreaseMarginPayload,
createDecreaseSizeAndIncreaseMarginPayload: () => createDecreaseSizeAndIncreaseMarginPayload,
createFlipPositionPayload: () => createFlipPositionPayload,
createGraphqlClient: () => createGraphqlClient,
createGraphqlClientWithUri: () => createGraphqlClientWithUri,
createIncreaseLimitOrderMarginPayload: () => createIncreaseLimitOrderMarginPayload,
createIncreaseMarginPayload: () => createIncreaseMarginPayload,
createIncreasePositionSizePayload: () => createIncreasePositionSizePayload,
createIncreaseSizeAndDecreaseMarginPayload: () => createIncreaseSizeAndDecreaseMarginPayload,
createIncreaseSizeAndIncreaseMarginPayload: () => createIncreaseSizeAndIncreaseMarginPayload,
createLiquidatePositionPayload: () => createLiquidatePositionPayload,
createLiquidateVaultBankruptPayload: () => createLiquidateVaultBankruptPayload,
createLiquidateVaultWithPartPayload: () => createLiquidateVaultWithPartPayload,
createMergeVaultsPaylaod: () => createMergeVaultsPaylaod,
createOpenPositionPayload: () => createOpenPositionPayload,
createOpenPositionWithTpslPayload: () => createOpenPositionWithTpslPayload,
createPlaceLimitOrderPayload: () => createPlaceLimitOrderPayload,
createPlaceTpslPayload: () => createPlaceTpslPayload,
createPositionAndPlaceLimitOrderPayload: () => createPositionAndPlaceLimitOrderPayload,
createPythClient: () => createPythClient,
createReferPayload: () => createReferPayload,
createReferViaCustomCodePayload: () => createReferViaCustomCodePayload,
createRemoveCollateralAndBorrow: () => createRemoveCollateralAndBorrow,
createRemoveCollateralPayload: () => createRemoveCollateralPayload,
createRepayDebtAndRemoveCollateralPayload: () => createRepayDebtAndRemoveCollateralPayload,
createRepayDebtPartPayload: () => createRepayDebtPartPayload,
createTriggerLimitOrderPayload: () => createTriggerLimitOrderPayload,
createTriggerTpslPayload: () => createTriggerTpslPayload,
createUpdateLimitOrderPayload: () => createUpdateLimitOrderPayload,
createUpdateReferralDepositAddressPayload: () => createUpdateReferralDepositAddressPayload,
createUpdateTpslPayload: () => createUpdateTpslPayload,
createUserProfilePayload: () => createUserProfilePayload,
createUserProfileWithCodePayload: () => createUserProfileWithCodePayload,
createVaultAndBorrowPayload: () => createVaultAndBorrowPayload,
createVaultPayload: () => createVaultPayload,
currentPeriodFeeRateView: () => currentPeriodFeeRateView,
defaultMirageNetworks: () => defaultMirageNetworks,
estimateFeeView: () => estimateFeeView,
fATotalSupplyView: () => fATotalSupplyView,
getAssetAmountArgument: () => getAssetAmountArgument,
getAssetAmountBCS: () => getAssetAmountBCS,
getChainIdByDeployment: () => getChainIdByDeployment,
getCollectionType: () => getCollectionType,
getDecimal8Argument: () => getDecimal8Argument,
getDecimal8BCS: () => getDecimal8BCS,
getDefaultFullnodeUrl: () => getDefaultFullnodeUrl,
getDefaultIndexerUrl: () => getDefaultIndexerUrl,
getDefaultMirageIndexerUrl: () => getDefaultMirageIndexerUrl,
getDefaultPythUrl: () => getDefaultPythUrl,
getDeploymentByChainId: () => getDeploymentByChainId,
getModuleAddress: () => getModuleAddress,
getMusdAddress: () => getMusdAddress,
getPrice: () => getPrice,
getPriceFeedUpdateData: () => getPriceFeedUpdateData,
getPropertyMapSigned64: () => getPropertyMapSigned64,
getPropertyMapU64: () => getPropertyMapU64,
getTpSlArgument: () => getTpSlArgument,
getUiPythPrice: () => getUiPythPrice,
getUserProfileCode: () => getUserProfileCode,
integerToDecimal: () => integerToDecimal,
isLimitOrderTriggerableBulkView: () => isLimitOrderTriggerableBulkView,
isLimitOrderTriggerableView: () => isLimitOrderTriggerableView,
liquidatableAmountsBulkView: () => liquidatableAmountsBulkView,
liquidationPriceBulkView: () => liquidationPriceBulkView,
liquidationPriceView: () => liquidationPriceView,
marketMarginOracleView: () => marketMarginOracleView,
marketMarginSymbolView: () => marketMarginSymbolView,
marketMarginTokenAddressView: () => marketMarginTokenAddressView,
marketNameView: () => marketNameView,
marketPerpOracleView: () => marketPerpOracleView,
marketPerpSymbolView: () => marketPerpSymbolView,
nextReferralRateView: () => nextReferralRateView,
normalizeAddress: () => normalizeAddress,
numberOfClaimsAvailableView: () => numberOfClaimsAvailableView,
oracleNameView: () => oracleNameView,
oraclePriceMultiplierView: () => oraclePriceMultiplierView,
ownedVaultAddressesByCollectionQuery: () => ownedVaultAddressesByCollectionQuery,
positionFundingView: () => positionFundingView,
positionIdsByMarketAndOwnerQuery: () => positionIdsByMarketAndOwnerQuery,
positionMaintenanceMarginMusdView: () => positionMaintenanceMarginMusdView,
priceFeedIdView: () => priceFeedIdView,
referralDepositAddressView: () => referralDepositAddressView,
stringToOrderType: () => stringToOrderType,
stringToPositionSide: () => stringToPositionSide,
timeUntilNextClaimView: () => timeUntilNextClaimView,
userAssetBalanceView: () => userAssetBalanceView,
userProfileExistsView: () => userProfileExistsView,
userProfileFeeVolumeView: () => userProfileFeeVolumeView,
userReferrerAddressView: () => userReferrerAddressView,
vaultCollectionAPRQuery: () => vaultCollectionAPRQuery,
vaultCollectionNameView: () => vaultCollectionNameView
});
module.exports = __toCommonJS(src_exports);
// src/client/base.ts
var import_ts_sdk22 = require("@aptos-labs/ts-sdk");
// src/utils/index.ts
var import_ts_sdk21 = require("@aptos-labs/ts-sdk");
var import_bignumber22 = __toESM(require("bignumber.js"));
// src/utils/config.ts
var import_ts_sdk = require("@aptos-labs/ts-sdk");
// mirage_config_movement.json
var mirage_config_movement_default = {
chainId: 126,
deployerAddress: "0x86d2ae026e602dbe39040457a6196ecdfc6308ab5b276d4379e10327b7204666",
vaults: [
{
name: "MOVE/mUSD CDP",
address: "0x81821b61b14a7899e6417c9f9b6a2a8871d6d27a2fc66fee97942425185d546f",
collateralSymbol: "MOVE",
borrowSymbol: "mUSD",
collateralOracle: "MOVE_PYTH",
borrowOracle: "STABLE_ORACLE"
}
],
oracles: [
{
name: "STABLE_ORACLE",
address: "0xea497f66440058b553a3bfbc9eb8a7608fa58e0ab6d7c3a20042e07b9cb8b24d",
priceFeedId: "",
priceMultiplier: 1
},
{
name: "MOVE_PYTH",
address: "0x91faa0e4ffcbf9131e1e217d954aeb0fa8ed46585e6be33a6650df75b0856f0d",
priceFeedId: "0x6bf748c908767baa762a1563d454ebec2d5108f8ee36d806aadacc8f0a075b6d",
priceMultiplier: 1
}
],
fungibleAssets: [
{
coinType: "0x1::aptos_coin::AptosCoin",
address: "0x000000000000000000000000000000000000000000000000000000000000000a",
decimals: 8,
name: "Move Coin",
symbol: "MOVE"
},
{
address: "0xdd84125d1ebac8f1ecb2819801417fc392325e672be111ec03830c34d6ff82dd",
decimals: 8,
name: "mirage dollar",
symbol: "mUSD"
}
],
markets: [
{
address: "0xc3337a2be5d9e37fd79b075d6f4ad3d3bd4c76835fe3c2a879fac5b3e61c6e48",
marginOracle: "STABLE_ORACLE",
perpOracle: "MOVE_PYTH",
perpSymbol: "MOVEPERP",
marginSymbol: "mUSD",
name: "MOVEPERP/mUSD"
}
]
};
// mirage_config_testnet.json
var mirage_config_testnet_default = {
chainId: 2,
deployerAddress: "0x86d2ae026e602dbe39040457a6196ecdfc6308ab5b276d4379e10327b7204666",
vaults: [
{
name: "tUSDC/mUSD CDP",
address: "0x8f3699188140d9d7acd406c9c3890f52569770178dfdfe26018f8818b547957f",
collateralSymbol: "tUSDC",
borrowSymbol: "mUSD",
collateralOracle: "USDC_PYTH",
borrowOracle: "STABLE_ORACLE"
},
{
name: "APT/mUSD CDP",
address: "0xe1e13aa968df88dff6ac5227eaa6220c90a0e40e60ce274695a134f43966e2c0",
collateralSymbol: "APT",
borrowSymbol: "mUSD",
collateralOracle: "APT_PYTH",
borrowOracle: "STABLE_ORACLE"
}
],
oracles: [
{
name: "STABLE_ORACLE",
address: "0xea497f66440058b553a3bfbc9eb8a7608fa58e0ab6d7c3a20042e07b9cb8b24d",
priceFeedId: "",
priceMultiplier: 1
},
{
name: "USDC_PYTH",
address: "0x1681450aa712554c31321d23a5dfdc7c4ea4d3e04d2375cdda3a48e89dbce0f7",
priceFeedId: "0x41f3625971ca2ed2263e78573fe5ce23e13d2558ed3f2e47ab0f84fb9e7ae722",
priceMultiplier: 1
},
{
name: "APT_PYTH",
address: "0xc21bdf1a4c16a5a7aad7c4a4feefde7ddf3122a149a92369c0044664b195f9cd",
priceFeedId: "0x44a93dddd8effa54ea51076c4e851b6cbbfd938e82eb90197de38fe8876bb66e",
priceMultiplier: 1
},
{
name: "BTC_PYTH",
address: "0x910baf8c8e45b7ba6729849e41ae2372b5ef127686893baddb913b772ab30356",
priceFeedId: "0xf9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b",
priceMultiplier: 1
},
{
name: "ETH_PYTH",
address: "0x4ceeb1b954e75cece12d4a9241b1ee1f06bf79519379aaa58d8e7dfb32479c3b",
priceFeedId: "0xca80ba6dc32e08d06f1aa886011eed1d77c77be9eb761cc10d72b7d0a2fd57a6",
priceMultiplier: 1
},
{
name: "SOL_PYTH",
address: "0x4ab336dc2801e3a05ff23918c789eda5df33b5fbf16add4c0457bad0e322707f",
priceFeedId: "0xfe650f0367d4a7ef9815a593ea15d36593f0643aaaf0149bb04be67ab851decd",
priceMultiplier: 1
},
{
name: "SUI_PYTH",
address: "0xb8f097a769793a979325953ff4705a7f781ba06f0fc0b426570545c8d652e7d5",
priceFeedId: "0x50c67b3fd225db8912a424dd4baed60ffdde625ed2feaaf283724f9608fea266",
priceMultiplier: 1
},
{
name: "MOVE_PYTH",
address: "0x91faa0e4ffcbf9131e1e217d954aeb0fa8ed46585e6be33a6650df75b0856f0d",
priceFeedId: "0xee0c08f6b500a5933e95f75169dcd8910d9ff8d4acc6d07c9f577113a2387b9c",
priceMultiplier: 1
},
{
name: "XAG_PYTH",
address: "0x9570dec57b6e651ae5efdc130520326ddbfeaecfcce024d3bcca077ffc331ccd",
priceFeedId: "0x321ba4d608fa75ba76d6d73daa715abcbdeb9dba02257f05a1b59178b49f599b",
priceMultiplier: 1
},
{
name: "XAU_PYTH",
address: "0x7151fde0d67b70c66b366fbc7b04aa8bc0a2b10fd206eee0309286aa5de1f8a5",
priceFeedId: "0x30a19158f5a54c0adf8fb7560627343f22a1bc852b89d56be1accdc5dbf96d0e",
priceMultiplier: 1
},
{
name: "EUR_PYTH",
address: "0xb4a587bf47a5013fa5d92d57fd617f61e795f34676d0e69a7bca408d9230e9f9",
priceFeedId: "0x30a19158f5a54c0adf8fb7560627343f22a1bc852b89d56be1accdc5dbf96d0e",
priceMultiplier: 1
},
{
name: "GBP_PYTH",
address: "0xee9753655840b2c873bc100133de3298cf807f407d7ad31811c18058e3f0e014",
priceFeedId: "0xbcbdc2755bd74a2065f9d3283c2b8acbd898e473bdb90a6764b3dbd467c56ecd",
priceMultiplier: 1
}
],
fungibleAssets: [
{
address: "0x7409091bec340a49aa0b5f4b32bc4b1f6aec05607622ff868bf8b1720e11aa40",
decimals: 8,
name: "testnet usdc",
symbol: "tUSDC"
},
{
address: "0xdd84125d1ebac8f1ecb2819801417fc392325e672be111ec03830c34d6ff82dd",
decimals: 8,
name: "mirage dollar",
symbol: "mUSD"
},
{
coinType: "0x1::aptos_coin::AptosCoin",
address: "0x000000000000000000000000000000000000000000000000000000000000000a",
decimals: 8,
name: "Aptos Coin",
symbol: "APT"
}
],
markets: [
{
address: "0xce54f046a632ce7a1ae5a53fc4ce85241b1b2c68e064b74a5e2d0d47c65f065e",
marginOracle: "STABLE_ORACLE",
perpOracle: "APT_PYTH",
perpSymbol: "APTPERP",
marginSymbol: "mUSD",
name: "APTPERP/mUSD"
},
{
address: "0x611ce4102776d7dbeafbaace9b8a3ebe536ebcb616ceb94bee19e7b0c7949e2c",
marginOracle: "STABLE_ORACLE",
perpOracle: "BTC_PYTH",
perpSymbol: "BTCPERP",
marginSymbol: "mUSD",
name: "BTCPERP/mUSD"
},
{
address: "0xe763c8309768c997a468bc8f263603d04a13487e0313c529cc85dc50ad2e95ff",
marginOracle: "STABLE_ORACLE",
perpOracle: "ETH_PYTH",
perpSymbol: "ETHPERP",
marginSymbol: "mUSD",
name: "ETHPERP/mUSD"
},
{
address: "0xc3337a2be5d9e37fd79b075d6f4ad3d3bd4c76835fe3c2a879fac5b3e61c6e48",
marginOracle: "STABLE_ORACLE",
perpOracle: "MOVE_PYTH",
perpSymbol: "MOVEPERP",
marginSymbol: "mUSD",
name: "MOVEPERP/mUSD"
},
{
address: "0xa833f96e42925f8277e4f2f23497bb36d01b1b3d9dd75c44dbbe7f351ef4e621",
marginOracle: "STABLE_ORACLE",
perpOracle: "SOL_PYTH",
perpSymbol: "SOLPERP",
marginSymbol: "mUSD",
name: "SOLPERP/mUSD"
},
{
address: "0xb47405b6da07670ffccdf2139ae2b04e99d0bf537277b69ada59780ee656c9ce",
marginOracle: "STABLE_ORACLE",
perpOracle: "SUI_PYTH",
perpSymbol: "SUIPERP",
marginSymbol: "mUSD",
name: "SUIPERP/mUSD"
},
{
address: "0x0517831dfa7e68715fbd0ff19306e95abfd31bf6a5d2e6bc6b6b47a8ea6c77bf",
marginOracle: "STABLE_ORACLE",
perpOracle: "XAG_PYTH",
perpSymbol: "XAGPERP",
marginSymbol: "mUSD",
name: "XAGPERP/mUSD"
},
{
address: "0x866a8c0812e3f42cfae8baac28451d8e73ab766e2890b1ddc2826a2daa98cb3e",
marginOracle: "STABLE_ORACLE",
perpOracle: "XAU_PYTH",
perpSymbol: "XAUPERP",
marginSymbol: "mUSD",
name: "XAUPERP/mUSD"
},
{
address: "0x5fb3c167f41e209ffd1e0f7e488aada6149cc503724d42799bc16932a9bac676",
marginOracle: "STABLE_ORACLE",
perpOracle: "EUR_PYTH",
perpSymbol: "EURPERP",
marginSymbol: "mUSD",
name: "EURPERP/mUSD"
},
{
address: "0xe961a196130e73b2cb80d25ce4d76b3d6372e9db7c41263fee177fc7c8ef30bd",
marginOracle: "STABLE_ORACLE",
perpOracle: "GBP_PYTH",
perpSymbol: "GBPPERP",
marginSymbol: "mUSD",
name: "GBPPERP/mUSD"
}
]
};
// mirage_mainnet_config.json
var mirage_mainnet_config_default = {
chainId: 1,
deployerAddress: "0x86d2ae026e602dbe39040457a6196ecdfc6308ab5b276d4379e10327b7204666",
vaults: [
{
name: "APT/mUSD CDP",
address: "0xe1e13aa968df88dff6ac5227eaa6220c90a0e40e60ce274695a134f43966e2c0",
collateralSymbol: "APT",
borrowSymbol: "mUSD",
collateralOracle: "APT_PYTH",
borrowOracle: "STABLE_ORACLE"
},
{
name: "USDC/mUSD CDP",
address: "0x3fb56c8c18ad3f20acf1ac971edfca4dd2bef1144e363aec83a04587675752f5",
collateralSymbol: "USDC",
borrowSymbol: "mUSD",
collateralOracle: "USDC_PYTH",
borrowOracle: "STABLE_ORACLE"
}
],
oracles: [
{
name: "STABLE_ORACLE",
address: "0xea497f66440058b553a3bfbc9eb8a7608fa58e0ab6d7c3a20042e07b9cb8b24d",
priceFeedId: "",
priceMultiplier: 1
},
{
name: "APT_PYTH",
address: "0xc21bdf1a4c16a5a7aad7c4a4feefde7ddf3122a149a92369c0044664b195f9cd",
priceFeedId: "0x03ae4db29ed4ae33d323568895aa00337e658e348b37509f5372ae51f0af00d5",
priceMultiplier: 1
},
{
name: "USDC_PYTH",
address: "0x1681450aa712554c31321d23a5dfdc7c4ea4d3e04d2375cdda3a48e89dbce0f7",
priceFeedId: "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
priceMultiplier: 1
}
],
fungibleAssets: [
{
coinType: "0x1::aptos_coin::AptosCoin",
address: "0x000000000000000000000000000000000000000000000000000000000000000a",
decimals: 8,
name: "Aptos Coin",
symbol: "APT"
},
{
address: "0xdd84125d1ebac8f1ecb2819801417fc392325e672be111ec03830c34d6ff82dd",
decimals: 8,
name: "mirage dollar",
symbol: "mUSD"
},
{
address: "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b",
decimals: 6,
name: "USDC",
symbol: "USDC"
}
],
markets: [
{
address: "0xce54f046a632ce7a1ae5a53fc4ce85241b1b2c68e064b74a5e2d0d47c65f065e",
marginOracle: "STABLE_ORACLE",
perpOracle: "APT_PYTH",
perpSymbol: "APTPERP",
marginSymbol: "mUSD",
name: "APTPERP/mUSD"
}
]
};
// src/utils/config.ts
var Deployment = /* @__PURE__ */ ((Deployment2) => {
Deployment2["APTOS_TESTNET"] = "testnet";
Deployment2["APTOS_MAINNET"] = "mainnet";
Deployment2["MOVEMENT_MAINNET"] = "movement";
return Deployment2;
})(Deployment || {});
var getDeploymentByChainId = (chainId) => {
if (chainId == 1) {
return "mainnet" /* APTOS_MAINNET */;
} else if (chainId == 2) {
return "testnet" /* APTOS_TESTNET */;
} else if (chainId == 126) {
return "movement" /* MOVEMENT_MAINNET */;
} else {
throw new Error("no deployment with chaindId");
}
};
var getChainIdByDeployment = (deployment) => {
switch (deployment) {
case "mainnet" /* APTOS_MAINNET */:
return 1;
case "testnet" /* APTOS_TESTNET */:
return 2;
case "movement" /* MOVEMENT_MAINNET */:
return 126;
default:
throw new Error("no deployment with chaindId");
}
};
var MirageConfig = class {
chainId;
deployerAddress;
markets;
vaults;
fungibleAssets;
oracles;
fullnodeUrl;
indexerUrl;
mirageIndexerUrl;
pythUrl;
aptosApiKey;
deployment;
constructor(options) {
if (options.deployment) {
this.deployment = options.deployment;
} else {
this.deployment = "testnet" /* APTOS_TESTNET */;
}
this.aptosApiKey = options.aptosApiKey;
this.pythUrl = options.pythUrl || getDefaultPythUrl(this.deployment);
this.mirageIndexerUrl = options.mirageIndexerUrl || getDefaultMirageIndexerUrl(this.deployment);
this.fullnodeUrl = options.fullnodeUrl || getDefaultFullnodeUrl(this.deployment);
this.indexerUrl = options.indexerUrl || getDefaultIndexerUrl(this.deployment);
let config;
if (options.customConfig) {
config = options.customConfig;
} else if (this.deployment == "testnet" /* APTOS_TESTNET */) {
config = mirage_config_testnet_default;
} else if (this.deployment == "mainnet" /* APTOS_MAINNET */) {
config = mirage_mainnet_config_default;
} else if (this.deployment == "movement" /* MOVEMENT_MAINNET */) {
config = mirage_config_movement_default;
} else {
console.warn(`unrecognized deployment ${this.deployment}, defaulting to mirage testnet config`);
config = mirage_config_testnet_default;
}
this.chainId = config.chainId;
this.deployerAddress = import_ts_sdk.AccountAddress.fromString(config.deployerAddress);
this.markets = {};
this.vaults = {};
this.fungibleAssets = {};
this.oracles = {};
config.markets.forEach((market) => this.markets[market.name] = market);
config.vaults.forEach((vault) => this.vaults[vault.name] = vault);
config.fungibleAssets.forEach((token) => this.fungibleAssets[token.symbol] = token);
config.oracles.forEach((oracle) => this.oracles[oracle.name] = oracle);
}
};
var defaultMirageNetworks = {
mainnet: {
fullnodeUrl: "https://fullnode.mainnet.aptoslabs.com/v1",
indexerUrl: "https://api.mainnet.aptoslabs.com/v1/graphql",
mirageIndexerUrl: "https://api-aptos-mainnet.mirage.money/v1/graphql",
pythUrl: "https://hermes.pyth.network"
},
testnet: {
fullnodeUrl: "https://fullnode.testnet.aptoslabs.com/v1",
indexerUrl: "https://api.testnet.aptoslabs.com/v1/graphql",
mirageIndexerUrl: "https://api-aptos-testnet.mirage.money/v1/graphql",
pythUrl: "https://hermes-beta.pyth.network"
},
movement: {
fullnodeUrl: "https://mainnet.movementnetwork.xyz/v1",
indexerUrl: "https://indexer.mainnet.movementnetwork.xyz/v1/graphql",
mirageIndexerUrl: "https://api-movement-mainnet.mirage.money/v1/graphql",
pythUrl: "https://hermes.pyth.network"
}
};
var getDefaultFullnodeUrl = (deployment) => {
switch (deployment) {
case "mainnet" /* APTOS_MAINNET */:
return defaultMirageNetworks["mainnet" /* APTOS_MAINNET */].fullnodeUrl;
case "testnet" /* APTOS_TESTNET */:
return defaultMirageNetworks["testnet" /* APTOS_TESTNET */].fullnodeUrl;
case "movement" /* MOVEMENT_MAINNET */:
return defaultMirageNetworks["movement" /* MOVEMENT_MAINNET */].fullnodeUrl;
default:
throw new Error(`cannot find deployment ${deployment}`);
}
};
var getDefaultIndexerUrl = (deployment) => {
switch (deployment) {
case "mainnet" /* APTOS_MAINNET */:
return defaultMirageNetworks["mainnet" /* APTOS_MAINNET */].indexerUrl;
case "testnet" /* APTOS_TESTNET */:
return defaultMirageNetworks["testnet" /* APTOS_TESTNET */].indexerUrl;
case "movement" /* MOVEMENT_MAINNET */:
return defaultMirageNetworks["movement" /* MOVEMENT_MAINNET */].indexerUrl;
default:
throw new Error(`cannot find deployment ${deployment}`);
}
};
var getDefaultMirageIndexerUrl = (deployment) => {
switch (deployment) {
case "mainnet" /* APTOS_MAINNET */:
return defaultMirageNetworks["mainnet" /* APTOS_MAINNET */].mirageIndexerUrl;
case "testnet" /* APTOS_TESTNET */:
return defaultMirageNetworks["testnet" /* APTOS_TESTNET */].mirageIndexerUrl;
case "movement" /* MOVEMENT_MAINNET */:
return defaultMirageNetworks["movement" /* MOVEMENT_MAINNET */].mirageIndexerUrl;
default:
throw new Error(`cannot find deployment ${deployment}`);
}
};
var getDefaultPythUrl = (deployment) => {
switch (deployment) {
case "mainnet" /* APTOS_MAINNET */:
return defaultMirageNetworks["mainnet" /* APTOS_MAINNET */].pythUrl;
case "testnet" /* APTOS_TESTNET */:
return defaultMirageNetworks["testnet" /* APTOS_TESTNET */].pythUrl;
case "movement" /* MOVEMENT_MAINNET */:
return defaultMirageNetworks["movement" /* MOVEMENT_MAINNET */].pythUrl;
default:
throw new Error(`cannot find deployment ${deployment}`);
}
};
// src/utils/configBuilder.ts
var import_ts_sdk18 = require("@aptos-labs/ts-sdk");
var import_bignumber19 = __toESM(require("bignumber.js"));
// src/views/fungibleAssetViews.ts
var import_bignumber = __toESM(require("bignumber.js"));
var userAssetBalanceView = async (userAddress, tokenMetadataAddress, coinType, tokenDecimals, aptosClient) => {
const result = await aptosClient.getAccountCoinAmount({
accountAddress: userAddress,
coinType,
faMetadataAddress: tokenMetadataAddress
});
const balance = (0, import_bignumber.default)(result);
return integerToDecimal(balance, tokenDecimals);
};
var allMirageAssetsView = async (aptosClient, deployerAddress) => {
const payload = {
function: `${getModuleAddress("mirage_core" /* MIRAGE_CORE */, deployerAddress)}::registry::all_mirage_assets`,
functionArguments: []
};
const result = (await aptosClient.view({ payload }))[0];
return result.map((value) => value.inner);
};
var fATotalSupplyView = async (faMetadataAddress, faDecimals, aptosClient) => {
const payload = {
function: "0x1::fungible_asset::supply",
functionArguments: [faMetadataAddress]
};
const [val] = await aptosClient.view({ payload });
const val_option = val;
const val_raw_num = val_option.unwrap();
return integerToDecimal((0, import_bignumber.default)(val_raw_num), faDecimals);
};
// src/views/marketViews.ts
var import_bignumber14 = __toESM(require("bignumber.js"));
// src/generated/aptos/graphql.ts
var import_graphql_tag = __toESM(require("graphql-tag"));
var Urql = __toESM(require("urql"));
var GetCollectionsByOwnerDocument = import_graphql_tag.default`
query GetCollectionsByOwner($OWNER: String!) {
current_collection_ownership_v2_view(where: {creator_address: {_eq: $OWNER}}) {
collection_name
collection_id
}
}
`;
var GetCurrentOwnerBalancesDocument = import_graphql_tag.default`
query getCurrentOwnerBalances($OWNER: String!, $ASSET_TYPES: [String!]!) {
current_fungible_asset_balances(
where: {_and: {owner_address: {_eq: $OWNER}, is_primary: {_eq: true}, asset_type: {_in: $ASSET_TYPES}}}
) {
owner_address
amount
owner_address
asset_type
}
}
`;
var GetTokenIdsFromCollectionByOwnerDocument = import_graphql_tag.default`
query GetTokenIdsFromCollectionByOwner($COLLECTION: String!, $OWNER: String!) {
current_token_datas_v2(
where: {collection_id: {_eq: $COLLECTION}, current_token_ownerships: {owner_address: {_eq: $OWNER}}, is_deleted_v2: {_eq: false}}
) {
token_data_id
}
}
`;
var GetTokenIdsFromCollectionsByOwnerDocument = import_graphql_tag.default`
query GetTokenIdsFromCollectionsByOwner($COLLECTIONS: [String!]!, $OWNER: String!) {
current_token_datas_v2(
where: {collection_id: {_in: $COLLECTIONS}, current_token_ownerships: {owner_address: {_eq: $OWNER}}, is_deleted_v2: {_eq: false}}
) {
token_data_id
}
}
`;
// src/transactions/index.ts
var import_bignumber13 = __toESM(require("bignumber.js"));
var import_ts_sdk16 = require("@aptos-labs/ts-sdk");
// src/transactions/marketTransactions.ts
var import_ts_sdk11 = require("@aptos-labs/ts-sdk");
// src/entities/market/limitOrder.ts
var import_ts_sdk4 = require("@aptos-labs/ts-sdk");
var import_bignumber4 = __toESM(require("bignumber.js"));
// src/entities/market/position.ts
var import_ts_sdk3 = require("@aptos-labs/ts-sdk");
var import_bignumber3 = __toESM(require("bignumber.js"));
// src/entities/market/tpsl.ts
var import_ts_sdk2 = require("@aptos-labs/ts-sdk");
var import_bignumber2 = __toESM(require("bignumber.js"));
var TpSl = class {
/**
* The side of the order
*/
side;
takeProfitPrice;
stopLossPrice;
marketObjectAddress;
positionObjectAddress;
objectAddress;
/**
* Construct a TpSl instance
* @param tpslResources the data to parse
*/
constructor(tpslResources, objectAddress, deployerAddress) {
this.objectAddress = objectAddress;
const tpslOrderType = TpSl.getTpslType(deployerAddress).toString();
const findTpSl = tpslResources.find((resource) => resource.type === tpslOrderType);
if (findTpSl == void 0)
throw new Error("TpSl object not found");
const tpsl = findTpSl.data;
const strategyType = `${getModuleAddress("market" /* MARKET */, deployerAddress)}::market::Strategy`;
const strategy = tpslResources.find((resource) => resource.type === strategyType);
if (strategy == void 0)
throw new Error("Strategy object not found");
this.side = Boolean(tpsl.is_long).valueOf() ? 1 /* LONG */ : 2 /* SHORT */;
this.takeProfitPrice = (0, import_bignumber2.default)(tpsl.take_profit_price).div(PRECISION_8);
this.stopLossPrice = (0, import_bignumber2.default)(tpsl.stop_loss_price).div(PRECISION_8);
this.positionObjectAddress = strategy.data.position.inner;
this.marketObjectAddress = strategy.data.market.inner;
}
static getTpslType(deployerAddress) {
return new import_ts_sdk2.TypeTagStruct(
new import_ts_sdk2.StructTag(
getModuleAddress("market" /* MARKET */, deployerAddress),
new import_ts_sdk2.Identifier("tpsl"),
new import_ts_sdk2.Identifier("TpSl"),
[]
)
);
}
};
// src/entities/market/position.ts
var PositionSide = /* @__PURE__ */ ((PositionSide2) => {
PositionSide2[PositionSide2["UNKNOWN"] = 0] = "UNKNOWN";
PositionSide2[PositionSide2["LONG"] = 1] = "LONG";
PositionSide2[PositionSide2["SHORT"] = 2] = "SHORT";
return PositionSide2;
})(PositionSide || {});
var OrderType = /* @__PURE__ */ ((OrderType2) => {
OrderType2[OrderType2["UNKNOWN"] = 0] = "UNKNOWN";
OrderType2[OrderType2["MARKET"] = 1] = "MARKET";
OrderType2[OrderType2["LIMIT"] = 2] = "LIMIT";
OrderType2[OrderType2["STOP"] = 3] = "STOP";
OrderType2[OrderType2["FLIP"] = 4] = "FLIP";
return OrderType2;
})(OrderType || {});
var stringToPositionSide = (str) => {
str = str.toLowerCase();
if (str == "l" || str == "long")
return 1 /* LONG */;
else if (str == "s" || str == "short")
return 2 /* SHORT */;
return 0 /* UNKNOWN */;
};
var stringToOrderType = (str) => {
str = str.toLowerCase();
if (str == "m" || str == "market")
return 1 /* MARKET */;
else if (str == "l" || str == "limit")
return 2 /* LIMIT */;
else if (str == "s" || str == "stop")
return 3 /* STOP */;
return 0 /* UNKNOWN */;
};
var Position = class {
/**
* The token id
*/
tokenId;
/**
* The market of the position
*/
market;
/**
* The positions side
*/
side;
/**
* The position data if open
*/
openingPrice;
margin;
positionSize;
fundingAccrued;
maintenanceMargin;
strategyAddresses;
/**
* The fees paid by this position in margin token
*/
feesPaid;
/**
* The funding paid by this position in margin token
*/
fundingPaid;
/**
* The trade pnl (realized_pnl - feesPaid - funding) in margin token
*/
tradePnl;
/**
* The realized pnl of this position in margin token
*/
realizedPnl;
tpsl;
limitOrders;
/**
* The positions initial leverage
*/
leverage;
objectAddress;
/**
* Construct an instance of a trader
* @param positionObjectResources Resources from position object account
* @param objectAddress the address of the vault collection object
* @param config the mirage config
*/
constructor(positionObjectResources, strategyObjectsResources, market, objectAddress, deployerAddress) {
this.limitOrders = [];
this.tpsl = void 0;
this.objectAddress = import_ts_sdk3.AccountAddress.fromString(objectAddress).toStringShort();
this.market = market;
const positionType = Position.getPositionType(deployerAddress).toString();
const tokenIdsType = "0x4::token::TokenIdentifiers";
const propertyMapType = "0x4::property_map::PropertyMap";
const position = positionObjectResources.find((resource) => resource.type === positionType);
if (position == void 0)
throw new Error("Position object not found");
const tokenIdentifiers = positionObjectResources.find((resource) => resource.type === tokenIdsType);
if (tokenIdentifiers == void 0)
throw new Error("TokenIdentifiers object not found");
this.tokenId = BigInt(tokenIdentifiers.data.index.value);
const propertyMap = positionObjectResources.find((resource) => resource.type === propertyMapType);
if (propertyMap == void 0)
throw new Error("PropertyMap object not found");
this.feesPaid = getPropertyMapU64("fees_paid", propertyMap.data).div(PRECISION_8);
this.fundingPaid = getPropertyMapSigned64("funding_paid", propertyMap.data).div(PRECISION_8);
this.tradePnl = getPropertyMapSigned64("realized_pnl", propertyMap.data).div(PRECISION_8);
this.realizedPnl = this.tradePnl.minus(this.feesPaid).minus(this.fundingPaid);
this.leverage = getPropertyMapU64("leverage", propertyMap.data).div(PERCENT_PRECISION);
this.openingPrice = (0, import_bignumber3.default)(position.data.last_settled_price).div(PRECISION_8);
const side = (0, import_bignumber3.default)(position.data.side);
if (side.eq(1)) {
this.side = 2 /* SHORT */;
} else if (side.eq(2)) {
this.side = 1 /* LONG */;
} else {
this.side = 0 /* UNKNOWN */;
}
this.margin = (0, import_bignumber3.default)(position.data.margin_amount).div(PRECISION_8);
this.positionSize = (0, import_bignumber3.default)(position.data.position_size).div(PRECISION_8);
const marketFundingAccumulated = this.side == 1 /* LONG */ ? market.longFundingAccumulated : market.shortFundingAccumulated;
const lastPositionFunding = (0, import_bignumber3.default)(position.data.last_funding_accumulated.magnitude).times(position.data.last_funding_accumulated.negative ? -1 : 1).div(FEE_PRECISION).div(PRECISION_8);
this.fundingAccrued = marketFundingAccumulated.minus(lastPositionFunding).times(this.positionSize);
this.maintenanceMargin = ZERO;
this.strategyAddresses = position.data.strategy_refs;
for (const strategyObjectResources of strategyObjectsResources) {
const strategyAddress = strategyObjectResources[0].data.transfer_events.guid.id.addr;
for (const strategyObjectResource of strategyObjectResources) {
if (strategyObjectResource.type === TpSl.getTpslType(deployerAddress).toString()) {
const tpsl = new TpSl(strategyObjectResources, strategyAddress, deployerAddress);
if (tpsl.positionObjectAddress == this.objectAddress) {
this.tpsl = tpsl;
}
break;
}
if (strategyObjectResource.type === LimitOrder.getLimitOrderType(deployerAddress).toString()) {
const limitOrder = new LimitOrder(strategyObjectResources, strategyAddress, deployerAddress);
if (limitOrder.positionObjectAddress == this.objectAddress) {
this.limitOrders.push(limitOrder);
}
break;
}
}
}
}
static getStrategyAddresses(positionObjectResources, deployerAddress) {
const positionType = Position.getPositionType(deployerAddress).toString();
const findPosition = positionObjectResources.find((resource) => resource.type === positionType);
if (!findPosition)
return [];
const strategyAddresses = findPosition.data.strategy_refs;
return strategyAddresses;
}
/**
* Returns bool on if the position is open
* @returns If the position is open
*/
isOpen() {
return this.side != 0 /* UNKNOWN */;
}
/**
* Calculates the leverage of a position given the prices
* @param position The position
* @param perpetualPrice The perpetual price
* @param marginPrice The margin price
* @returns The leverage, where 1 == 1x leverage
*/
static getLeverage(position, perpetualPrice, marginPrice) {
return position.positionSize.div(position.margin).minus(position.fundingAccrued).times(perpetualPrice).div(marginPrice).toNumber();
}
/**
* Estimates a positions pnl in terms of the margin type
* @param position The position
* @param perpetualPrice The perpetual price
* @param marginPrice The margin price
* @returns The amount of pnl in terms of the margin of the market
*/
static estimatePnl(position, perpetualPrice, marginPrice) {
return (0, import_bignumber3.default)(perpetualPrice).minus(position.openingPrice).times(position.positionSize).div(marginPrice).times(position.side == 1 /* LONG */ ? 1 : -1).minus(position.fundingAccrued).toNumber();
}
/**
* Estimates a positions percent pnl in terms of the margin
* @param position The position
* @param perpetualPrice The perpetual price
* @param marginPrice The margin price
* @returns The percent pnl in terms of the margin of the market
*/
static estimatePercentPnl(position, perpetualPrice, marginPrice) {
return Position.estimatePnl(position, perpetualPrice, marginPrice) * 100 / position.margin.toNumber();
}
getPositionMaintenanceMarginMUSD(perpPrice, marginPrice) {
if (!this.isOpen) {
return ZERO;
}
const closeFee = this.market.getOpenCloseFee(
this.side,
true,
// close
this.positionSize,
perpPrice,
marginPrice
);
const positionSizeMUSD = this.positionSize.times(perpPrice);
return (0, import_bignumber3.default)(this.market.maintenanceMargin).times(positionSizeMUSD).plus(closeFee);
}
getLiquidationPrice(perpPrice, marginPrice) {
if (!this.isOpen) {
return ZERO;
}
const pnl = Position.estimatePnl(this, perpPrice.toNumber(), marginPrice.toNumber());
const maintenanceMargin = this.getPositionMaintenanceMarginMUSD(perpPrice, marginPrice);
const openingPrice = this.openingPrice;
let rawMargin = this.margin;
rawMargin = rawMargin.plus(pnl);
const marginMUSD = rawMargin.times(marginPrice);
if (marginMUSD.lte(maintenanceMargin)) {
return this.side == 1 /* LONG */ ? (0, import_bignumber3.default)(U64_MAX) : ZERO;
}
const marginScalar = marginMUSD.minus(maintenanceMargin).div(this.positionSize);
if (this.side == 1 /* LONG */ && openingPrice.gt(marginScalar)) {
return openingPrice.minus(marginScalar);
} else if (this.side == 2 /* SHORT */ && marginScalar.plus(openingPrice).lt((0, import_bignumber3.default)(U64_MAX))) {
return marginScalar.plus(openingPrice);
} else if (this.side == 1 /* LONG */) {
return ZERO;
} else {
return (0, import_bignumber3.default)(U64_MAX);
}
}
static getPositionType(deployerAddress) {
return new import_ts_sdk3.TypeTagStruct(
new import_ts_sdk3.StructTag(
getModuleAddress("market" /* MARKET */, deployerAddress),
new import_ts_sdk3.Identifier("market"),
new import_ts_sdk3.Identifier("Position"),
[]
)
);
}
};
// src/entities/market/limitOrder.ts
var LimitOrder = class {
/**
* The side of the order
*/
side;
/**
* Is this a limit order only to decrease a position
*/
isDecreaseOnly;
/**
* Position size in units of the asset
*/
positionSize;
/**
* This trades margin amount
*/
margin;
/**
* The price this order gets triggered
*/
triggerPrice;
/**
* Will this order trigger above or below the triggerPrice
*/
triggersAbove;
/**
* The max price slippage on trigger for the order
*/
maxPriceSlippage;
/**
* The expiration time of the order
*/
expiration;
marketObjectAddress;
positionObjectAddress;
objectAddress;
/**
* Construct a LimitOrder instance
* @param limitOrderData the data to parse
*/
constructor(limitOrderResources, objectAddress, deployerAddress) {
this.objectAddress = objectAddress;
const limitOrderType = LimitOrder.getLimitOrderType(deployerAddress).toString();
const findLimitOrder = limitOrderResources.find((resource) => resource.type === limitOrderType);
if (findLimitOrder == void 0)
throw new Error("LimitOrder object not found");
const limitOrder = findLimitOrder.data;
const strategyType = `${getModuleAddress("market" /* MARKET */, deployerAddress)}::market::Strategy`;
const strategy = limitOrderResources.find((resource) => resource.type === strategyType);
if (strategy == void 0)
throw new Error("Strategy object not found");
this.side = Boolean(limitOrder.is_long).valueOf() ? 1 /* LONG */ : 2 /* SHORT */;
this.isDecreaseOnly = limitOrder.is_decrease_only;
this.positionSize = (0, import_bignumber4.default)(limitOrder.position_size).div(PRECISION_8);
this.triggersAbove = Boolean(limitOrder.triggers_above);
this.triggerPrice = (0, import_bignumber4.default)(limitOrder.trigger_price).div(PRECISION_8);
this.maxPriceSlippage = (0, import_bignumber4.default)(limitOrder.max_price_slippage).div(PRECISION_8);
this.expiration = BigInt(limitOrder.expiration);
this.margin = (0, import_bignumber4.default)(strategy.data.strategy_margin_amount).div(PRECISION_8);
this.positionObjectAddress = strategy.data.position.inner;
this.marketObjectAddress = strategy.data.market.inner;
}
// Good-til-cancelled expiration (U64_MAX)
static gtcExpiration() {
return BigInt(U64_MAX);
}
// Whether this order has an expiration or is good-til-cancelled
isGtc() {
return this.expiration == LimitOrder.gtcExpiration();
}
/**
* Turn a percentage slippage into a price slippage
* @param triggerPrice The trigger price of the trade
* @param percentSlippage The allowed slippage in basis points
* @returns The amount of price slippage allowed
*/
static percentSlippageToPriceSlippage(triggerPrice, percentSlippage) {
return triggerPrice.times(percentSlippage).div(1e4);
}
static getLimitOrderType(deployerAddress) {
return new import_ts_sdk4.TypeTagStruct(
new import_ts_sdk4.StructTag(
getModuleAddress("market" /* MARKET */, deployerAddress),
new import_ts_sdk4.Identifier("limit_order"),
new import_ts_sdk4.Identifier("LimitOrder"),
[]
)
);
}
};
// src/entities/market/market.ts
var import_bignumber5 = __toESM(require("bignumber.js"));
var Market = class {
/**
* The markets perp symbol
*/
perpSymbol;
/**
* The markets perp symbol
*/
marginTokenAddress;
/**
* The total long margin of a market
*/
totalLongMargin;
/**
* The total short margin of a market
*/
totalShortMargin;
/**
* Long open interest in musd
*/
longOpenInterest;
/**
* Short open interest in musd
*/
shortOpenInterest;
/**
* Long open interest in musd
*/
longFundingAccumulated;
/**
* Short open interest in musd
*/
shortFundingAccumulated;
/**
* The funding that will be taken next funding round
*/
nextFundingRate;
/**
* The time of the last funding round
*/
lastFundingRound;
/**
* Whether long positions are close only
*/
longCloseOnly;
/**
* Whether short positions are close only
*/
shortCloseOnly;
// FeeInfo
/**
* Minimum taker fee at equal oi
*/
minTakerFee;
/**
* Maximum taker fee at the max_oi_imbalance
*/
maxTakerFee;
/**
* Min maker fee at large oi imbalance
*/
minMakerFee;
/**
* Max maker fee at equal oi
*/
maxMakerFee;
// FundingInfo
/**
* The minimum funding rate
*/
minFundingRate;
/**
* The maximum funding rate
*/
maxFundingRate;
/**
* The maximum funding rate
*/
baseFundingRate;
/**
* The interval between funding payments
*/
fundingInterval;
// MarketConfig
/**
* The max total oi allowed for the long & short sides
*/
maxOpenInterest;
/**
* The max allowed imbalance between long and short oi
*/
maxOpenInterestImbalance;
/**
* The base percent maintenance margin
*/
maintenanceMargin;
/**
* The max leverage for this market
*/
maxLeverage;
/**
* The min order size in mUSD for a trade
*/
minOrderSize;
/**
* The max order size in mUSD for a trade
*/
maxOrderSize;
/**
* The market collection address
*/
objectAddress;
/**
* Construct an instance of Market
* @param marketObjectResources resources from the market token collection account
* @param marginCoin the margin asset of the market
* @param perpetualAsset the asset being traded
*/
constructor(marketObjectResources, objectAddress, deployerAddress) {
this.objectAddress = objectAddress;
const marketType = `${getModuleAddress("market" /* MARKET */, deployerAddress)}::market::Market`;
const market = marketObjectResources.find((resource) => resource.type === marketType);
if (market == void 0)
throw new Error("Market object not found");
this.perpSymbol = market.data.perp_symbol;
this.marginTokenAddress = market.data.margin_token.inner;
this.totalLongMargin = new import_bignumber5.default(market.data.totalLongMargin).div(PRECISION_8);
this.totalShortMargin = new import_bignumber5.default(market.data.totalShortMargin).div(PRECISION_8);
this.longOpenInterest = new import_bignumber5.default(market.data.long_oi).div(PRECISION_8);
this.shortOpenInterest = new import_bignumber5.default(market.data.short_oi).div(PRECISION_8);
this.longFundingAccumulated = new import_bignumber5.default(market.data.long_funding_accumulated_per_unit.magnitude).times(market.data.long_funding_accumulated_per_unit.negative ? -1 : 1).div(FEE_PRECISION).div(PRECISION_8);
this.shortFundingAccumulated = new import_bignumber5.default(market.data.short_funding_accumulated_per_unit.magnitude).times(market.data.short_funding_accumulated_per_unit.negative ? -1 : 1).div(FEE_PRECISION).div(PRECISION_8);
this.nextFundingRate = new import_bignumber5.default(market.data.next_funding_rate.magnitude).times(market.data.next_funding_rate.negative ? -1 : 1).div(FEE_PRECISION);
this.lastFundingRound = new Date(new import_bignumber5.default(market.data.last_funding_round).times(1e3).toNumber());
this.longCloseOnly = Boolean(market.data.is_long_close_only);
this.shortCloseOnly = Boolean(market.data.is_short_close_only);
this.minTakerFee = new import_bignumber5.default(market.data.config.fees.min_taker_fee).div(FEE_PRECISION).toNumber();
this.maxTakerFee = new import_bignumber5.default(market.data.config.fees.max_taker_fee).div(FEE_PRECISION).toNumber();
this.minMakerFee = new import_bignumber5.default(market.data.config.fees.min_maker_fee).div(FEE_PRECISION).toNumber();
this.maxMakerFee = !!market ? new import_bignumber5.default(market.data.config.fees.max_maker_fee).div(FEE_PRECISION).toNumber() : 0;
this.minFundingRate = !!market ? new import_bignumber5.default(market.data.config.funding.min_funding_rate).div(FEE_PRECISION).toNumber() : 0;
this.maxFundingRate = !!market ? new import_bignumber5.default(market.data.config.funding.max_funding_rate).div(FEE_PRECISION).toNumber() : 0;
this.baseFundingRate = !!market ? new import_bignumber5.default(market.data.config.funding.base_funding_rate