@katanaperps/katana-perps-sdk 0.0.0-placeholder

package/dist/signatures.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidToUint128 = exports.uuidToHexString = exports.uint128ToUuid = exports.getInitialMarginFractionOverrideSettingsSignatureTypedData = exports.getWithdrawalSignatureTypedData = exports.getWithdrawalFromManagedAccountBySharesSignatureTypedData = exports.getWithdrawalFromManagedAccountByQuantitySignatureTypedData = exports.getWithdrawalFromManagedAccountContractStructSignatureTypedData = exports.getRemoveVaultXConnectionSignatureTypedData = exports.getSetVaultXConnectionSignatureTypedData = exports.getSetVaultDetailsSignatureTypedData = exports.getOrderCancellationSignatureTypedData = exports.getOrderCancellationByWalletSignatureTypedData = exports.getOrderCancellationByMarketSymbolSignatureTypedData = exports.getOrderCancellationByDelegatedKeySignatureTypedData = exports.getOrderCancellationByOrderIdSignatureTypedData = exports.getOrderSignatureTypedData = exports.getDelegatedKeyAuthorizationSignatureTypedData = exports.getWalletUnlockSignatureTypedData = exports.getWalletAssociationSignatureTypedData = exports.getDomainSeparator = exports.createPrivateKeyTypedDataSigner = void 0;
+const tslib_1 = require("tslib");
+const ethers_1 = require("ethers");
+const uuid_1 = require("uuid");
+const constants = tslib_1.__importStar(require("#constants"));
+const _utils_1 = require("#utils");
+const signature_1 = require("#types/enums/signature");
+const pipmath_1 = require("./pipmath");
+function createPrivateKeyTypedDataSigner(walletPrivateKey) {
+    return (...parameters) => new ethers_1.ethers.Wallet(walletPrivateKey).signTypedData(...parameters);
+}
+exports.createPrivateKeyTypedDataSigner = createPrivateKeyTypedDataSigner;
+const getDomainSeparator = (contractAddress, chainId, sandbox) => {
+    return {
+        name: constants.EIP_712_DOMAIN_NAME,
+        version: sandbox ?
+            constants.EIP_712_DOMAIN_VERSION_SANDBOX
+            : constants.EIP_712_DOMAIN_VERSION,
+        chainId,
+        verifyingContract: contractAddress,
+    };
+};
+exports.getDomainSeparator = getDomainSeparator;
+const getWalletAssociationSignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            WalletAssociation: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+        },
+    ];
+};
+exports.getWalletAssociationSignatureTypedData = getWalletAssociationSignatureTypedData;
+const getWalletUnlockSignatureTypedData = ({ nonce }, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            WalletUnlock: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'message', type: 'string' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(nonce),
+            message: constants.WALLET_SIGNATURE_MESSAGE,
+        },
+    ];
+};
+exports.getWalletUnlockSignatureTypedData = getWalletUnlockSignatureTypedData;
+const getDelegatedKeyAuthorizationSignatureTypedData = ({ delegatedKey, nonce }, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            DelegatedKeyAuthorization: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'delegatedPublicKey', type: 'address' },
+                { name: 'message', type: 'string' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(nonce),
+            delegatedPublicKey: delegatedKey,
+            message: constants.WALLET_SIGNATURE_MESSAGE,
+        },
+    ];
+};
+exports.getDelegatedKeyAuthorizationSignatureTypedData = getDelegatedKeyAuthorizationSignatureTypedData;
+const getOrderSignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    const emptyPipString = '0.00000000';
+    const { conditionalOrderId, triggerPrice, triggerType } = data;
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            Order: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'marketSymbol', type: 'string' },
+                { name: 'orderType', type: 'uint8' },
+                { name: 'orderSide', type: 'uint8' },
+                { name: 'quantity', type: 'string' },
+                { name: 'limitPrice', type: 'string' },
+                { name: 'triggerPrice', type: 'string' },
+                { name: 'triggerType', type: 'uint8' },
+                { name: 'callbackRate', type: 'string' },
+                { name: 'conditionalOrderId', type: 'uint128' },
+                { name: 'isReduceOnly', type: 'bool' },
+                { name: 'timeInForce', type: 'uint8' },
+                { name: 'selfTradePrevention', type: 'uint8' },
+                { name: 'isLiquidationAcquisitionOnly', type: 'bool' },
+                { name: 'delegatedPublicKey', type: 'address' },
+                { name: 'clientOrderId', type: 'string' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            marketSymbol: data.market,
+            orderType: signature_1.OrderTypeSigEnum[data.type],
+            orderSide: signature_1.OrderSideSigEnum[data.side],
+            quantity: data.quantity,
+            limitPrice: data.price || emptyPipString,
+            triggerPrice: triggerPrice || emptyPipString,
+            triggerType: triggerType !== undefined ?
+                signature_1.OrderTriggerTypeSigEnum[triggerType]
+                : signature_1.OrderTriggerTypeSigEnum.none,
+            callbackRate: data.callbackRate || emptyPipString,
+            conditionalOrderId: conditionalOrderId !== undefined ?
+                uuidToUint128(conditionalOrderId)
+                : 0,
+            isReduceOnly: !!data.reduceOnly,
+            timeInForce: data.timeInForce ? signature_1.OrderTimeInForceSigEnum[data.timeInForce] : 0,
+            selfTradePrevention: data.selfTradePrevention ?
+                signature_1.OrderSelfTradePreventionSigEnum[data.selfTradePrevention]
+                : 0,
+            isLiquidationAcquisitionOnly: data.isLiquidationAcquisitionOnly ?? false,
+            delegatedPublicKey: data.delegatedKey || ethers_1.ethers.ZeroAddress,
+            clientOrderId: data.clientOrderId || '',
+        },
+    ];
+};
+exports.getOrderSignatureTypedData = getOrderSignatureTypedData;
+const getOrderCancellationByOrderIdSignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            OrderCancellationByOrderId: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'delegatedKey', type: 'address' },
+                { name: 'orderIds', type: 'string[]' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            delegatedKey: data.delegatedKey || ethers_1.ethers.ZeroAddress,
+            orderIds: data.orderIds,
+        },
+    ];
+};
+exports.getOrderCancellationByOrderIdSignatureTypedData = getOrderCancellationByOrderIdSignatureTypedData;
+const getOrderCancellationByDelegatedKeySignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            OrderCancellationByDelegatedKey: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'delegatedKey', type: 'address' },
+                { name: 'orderDelegatedKey', type: 'address' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            delegatedKey: data.delegatedKey || ethers_1.ethers.ZeroAddress,
+            orderDelegatedKey: data.orderDelegatedKey,
+        },
+    ];
+};
+exports.getOrderCancellationByDelegatedKeySignatureTypedData = getOrderCancellationByDelegatedKeySignatureTypedData;
+const getOrderCancellationByMarketSymbolSignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            OrderCancellationByMarketSymbol: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'delegatedKey', type: 'address' },
+                { name: 'marketSymbol', type: 'string' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            delegatedKey: data.delegatedKey || ethers_1.ethers.ZeroAddress,
+            marketSymbol: data.market,
+        },
+    ];
+};
+exports.getOrderCancellationByMarketSymbolSignatureTypedData = getOrderCancellationByMarketSymbolSignatureTypedData;
+const getOrderCancellationByWalletSignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            OrderCancellationByWallet: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'delegatedKey', type: 'address' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            delegatedKey: data.delegatedKey || ethers_1.ethers.ZeroAddress,
+        },
+    ];
+};
+exports.getOrderCancellationByWalletSignatureTypedData = getOrderCancellationByWalletSignatureTypedData;
+const getOrderCancellationSignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    if (data.orderIds) {
+        return (0, exports.getOrderCancellationByOrderIdSignatureTypedData)(data, contractAddress, chainId, sandbox);
+    }
+    if (data.orderDelegatedKey) {
+        return (0, exports.getOrderCancellationByDelegatedKeySignatureTypedData)(data, contractAddress, chainId, sandbox);
+    }
+    if (data.market) {
+        return (0, exports.getOrderCancellationByMarketSymbolSignatureTypedData)(data, contractAddress, chainId, sandbox);
+    }
+    return (0, exports.getOrderCancellationByWalletSignatureTypedData)(data, contractAddress, chainId, sandbox);
+};
+exports.getOrderCancellationSignatureTypedData = getOrderCancellationSignatureTypedData;
+function getSetVaultDetailsSignatureTypedData(data, contractAddress, chainId, sandbox) {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            InitialMarginFractionOverrideSettings: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'delegatedPublicKey', type: 'address' },
+                { name: 'name', type: 'string' },
+                { name: 'description', type: 'string' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            delegatedPublicKey: data.delegatedKey || ethers_1.ethers.ZeroAddress,
+            name: data.name,
+            description: data.description,
+        },
+    ];
+}
+exports.getSetVaultDetailsSignatureTypedData = getSetVaultDetailsSignatureTypedData;
+function getSetVaultXConnectionSignatureTypedData(data, contractAddress, chainId, sandbox) {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            SetVaultXConnection: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'code', type: 'string' },
+                { name: 'manager', type: 'address' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            code: data.code,
+            manager: data.manager,
+        },
+    ];
+}
+exports.getSetVaultXConnectionSignatureTypedData = getSetVaultXConnectionSignatureTypedData;
+function getRemoveVaultXConnectionSignatureTypedData(data, contractAddress, chainId, sandbox) {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            RemoveVaultXConnection: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'manager', type: 'address' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            manager: data.manager,
+        },
+    ];
+}
+exports.getRemoveVaultXConnectionSignatureTypedData = getRemoveVaultXConnectionSignatureTypedData;
+const getWithdrawalFromManagedAccountContractStructSignatureTypedData = async (data, contractAddress, chainId, sandbox) => {
+    if (Number(data.withdrawalType) === signature_1.ManagedAccountWithdrawalType.byQuantity) {
+        return (0, exports.getWithdrawalFromManagedAccountByQuantitySignatureTypedData)({
+            nonce: uint128ToUuid(data.withdrawalByQuantity.nonce),
+            managerWallet: await ethers_1.ethers.resolveAddress(data.withdrawalByQuantity.managerWallet),
+            wallet: await ethers_1.ethers.resolveAddress(data.withdrawalByQuantity.depositorWallet),
+            quantity: (0, pipmath_1.pipToDecimal)(BigInt(data.withdrawalByQuantity.grossQuantity)),
+            maxShares: (0, pipmath_1.pipToDecimal)(BigInt(data.withdrawalByQuantity.maxShares)),
+            maximumGasFee: (0, pipmath_1.pipToDecimal)(BigInt(data.withdrawalByQuantity.maximumGasFee)),
+            managedAccountProvider: await ethers_1.ethers.resolveAddress(data.withdrawalByQuantity.managedAccountProvider),
+            managedAccountProviderPayload: ethers_1.ethers.hexlify(data.withdrawalByQuantity.managedAccountProviderPayload),
+            bridgeAdapterAddress: await ethers_1.ethers.resolveAddress(data.withdrawalByQuantity.bridgeAdapter),
+            bridgeAdapterPayload: ethers_1.ethers.hexlify(data.withdrawalByQuantity.bridgeAdapterPayload),
+        }, contractAddress, chainId, sandbox);
+    }
+    if (Number(data.withdrawalType) === signature_1.ManagedAccountWithdrawalType.byShares) {
+        return (0, exports.getWithdrawalFromManagedAccountBySharesSignatureTypedData)({
+            nonce: uint128ToUuid(data.withdrawalByShares.nonce),
+            managerWallet: await ethers_1.ethers.resolveAddress(data.withdrawalByShares.managerWallet),
+            wallet: await ethers_1.ethers.resolveAddress(data.withdrawalByShares.depositorWallet),
+            shares: (0, pipmath_1.pipToDecimal)(BigInt(data.withdrawalByShares.shares)),
+            minimumQuantity: (0, pipmath_1.pipToDecimal)(BigInt(data.withdrawalByShares.minimumQuantity)),
+            maximumGasFee: (0, pipmath_1.pipToDecimal)(BigInt(data.withdrawalByShares.maximumGasFee)),
+            managedAccountProvider: await ethers_1.ethers.resolveAddress(data.withdrawalByShares.managedAccountProvider),
+            managedAccountProviderPayload: ethers_1.ethers.hexlify(data.withdrawalByShares.managedAccountProviderPayload),
+            bridgeAdapterAddress: await ethers_1.ethers.resolveAddress(data.withdrawalByShares.bridgeAdapter),
+            bridgeAdapterPayload: ethers_1.ethers.hexlify(data.withdrawalByShares.bridgeAdapterPayload),
+        }, contractAddress, chainId, sandbox);
+    }
+    throw new Error(`Invalid ManagedAccountWithdrawalType ${data.withdrawalType}`);
+};
+exports.getWithdrawalFromManagedAccountContractStructSignatureTypedData = getWithdrawalFromManagedAccountContractStructSignatureTypedData;
+const getWithdrawalFromManagedAccountByQuantitySignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            WithdrawalFromManagedAccountByQuantity: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'managerWallet', type: 'address' },
+                { name: 'depositorWallet', type: 'address' },
+                { name: 'quantity', type: 'string' },
+                { name: 'maxShares', type: 'string' },
+                { name: 'maximumGasFee', type: 'string' },
+                { name: 'managedAccountProvider', type: 'address' },
+                { name: 'managedAccountProviderPayload', type: 'bytes' },
+                { name: 'bridgeAdapter', type: 'address' },
+                { name: 'bridgeAdapterPayload', type: 'bytes' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            managerWallet: data.managerWallet,
+            depositorWallet: data.wallet,
+            quantity: data.quantity,
+            maxShares: data.maxShares,
+            maximumGasFee: data.maximumGasFee,
+            managedAccountProvider: data.managedAccountProvider,
+            managedAccountProviderPayload: data.managedAccountProviderPayload,
+            bridgeAdapter: data.bridgeAdapterAddress,
+            bridgeAdapterPayload: data.bridgeAdapterPayload,
+        },
+    ];
+};
+exports.getWithdrawalFromManagedAccountByQuantitySignatureTypedData = getWithdrawalFromManagedAccountByQuantitySignatureTypedData;
+const getWithdrawalFromManagedAccountBySharesSignatureTypedData = (data, contractAddress, chainId, sandbox) => {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            WithdrawalFromManagedAccountByShares: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'managerWallet', type: 'address' },
+                { name: 'depositorWallet', type: 'address' },
+                { name: 'shares', type: 'string' },
+                { name: 'minimumQuantity', type: 'string' },
+                { name: 'maximumGasFee', type: 'string' },
+                { name: 'managedAccountProvider', type: 'address' },
+                { name: 'managedAccountProviderPayload', type: 'bytes' },
+                { name: 'bridgeAdapter', type: 'address' },
+                { name: 'bridgeAdapterPayload', type: 'bytes' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            managerWallet: data.managerWallet,
+            depositorWallet: data.wallet,
+            shares: data.shares,
+            minimumQuantity: data.minimumQuantity,
+            maximumGasFee: data.maximumGasFee,
+            managedAccountProvider: data.managedAccountProvider,
+            managedAccountProviderPayload: data.managedAccountProviderPayload,
+            bridgeAdapter: data.bridgeAdapterAddress,
+            bridgeAdapterPayload: data.bridgeAdapterPayload,
+        },
+    ];
+};
+exports.getWithdrawalFromManagedAccountBySharesSignatureTypedData = getWithdrawalFromManagedAccountBySharesSignatureTypedData;
+function getWithdrawalSignatureTypedData(data, contractAddress, chainId, sandbox) {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            Withdrawal: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'quantity', type: 'string' },
+                { name: 'maximumGasFee', type: 'string' },
+                { name: 'bridgeAdapter', type: 'address' },
+                { name: 'bridgeAdapterPayload', type: 'bytes' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            quantity: data.quantity,
+            maximumGasFee: data.maximumGasFee,
+            bridgeAdapter: data.bridgeAdapterAddress,
+            bridgeAdapterPayload: data.bridgeAdapterPayload,
+        },
+    ];
+}
+exports.getWithdrawalSignatureTypedData = getWithdrawalSignatureTypedData;
+function getInitialMarginFractionOverrideSettingsSignatureTypedData(data, contractAddress, chainId, sandbox) {
+    (0, _utils_1.assertNonceIsValid)(data.nonce);
+    return [
+        (0, exports.getDomainSeparator)(contractAddress, chainId, sandbox),
+        {
+            InitialMarginFractionOverrideSettings: [
+                { name: 'nonce', type: 'uint128' },
+                { name: 'wallet', type: 'address' },
+                { name: 'marketSymbol', type: 'string' },
+                { name: 'initialMarginFractionOverride', type: 'string' },
+                { name: 'delegatedPublicKey', type: 'address' },
+            ],
+        },
+        {
+            nonce: uuidToUint128(data.nonce),
+            wallet: data.wallet,
+            marketSymbol: data.market,
+            initialMarginFractionOverride: data.initialMarginFractionOverride ?? '', // Initial Margin Fraction override value, blank if removing override
+            delegatedPublicKey: data.delegatedKey || ethers_1.ethers.ZeroAddress,
+        },
+    ];
+}
+exports.getInitialMarginFractionOverrideSettingsSignatureTypedData = getInitialMarginFractionOverrideSettingsSignatureTypedData;
+function uint128ToUuid(uint) {
+    return (0, uuid_1.stringify)(ethers_1.ethers.getBytes(ethers_1.ethers.toBeHex(uint, 16)));
+}
+exports.uint128ToUuid = uint128ToUuid;
+function uuidToHexString(uuid) {
+    return `0x${uuid.replace(/-/g, '')}`;
+}
+exports.uuidToHexString = uuidToHexString;
+function uuidToUint128(uuid) {
+    return BigInt.asUintN(128, BigInt(uuidToHexString(uuid)));
+}
+exports.uuidToUint128 = uuidToUint128;

package/dist/tests/orderbook/quantities/calculateInitialMarginFractionWithOverride.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=calculateInitialMarginFractionWithOverride.test.d.ts.map

package/dist/tests/orderbook/quantities/calculateInitialMarginFractionWithOverride.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateInitialMarginFractionWithOverride.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/orderbook/quantities/calculateInitialMarginFractionWithOverride.test.ts"],"names":[],"mappings":""}

package/dist/tests/orderbook/quantities/calculateInitialMarginFractionWithOverride.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chai = tslib_1.__importStar(require("chai"));
+const _pipmath_1 = require("#pipmath");
+const orderbook = tslib_1.__importStar(require("#orderbook/index"));
+const { expect } = chai;
+const defaultLeverageParameters = {
+    initialMarginFraction: (0, _pipmath_1.decimalToPip)('0.03'),
+    incrementalInitialMarginFraction: (0, _pipmath_1.decimalToPip)('0.01'),
+    basePositionSize: (0, _pipmath_1.decimalToPip)('1000'),
+    incrementalPositionSize: (0, _pipmath_1.decimalToPip)('100'),
+    maximumPositionSize: (0, _pipmath_1.decimalToPip)('100000'), // Unused
+    maintenanceMarginFraction: (0, _pipmath_1.decimalToPip)('0.01'), // Unused
+};
+describe('orderbook/quantities', () => {
+    describe('calculateInitialMarginFractionWithOverride', () => {
+        it('should succeed', () => {
+            const runScenario = (baseQuantity, expectedImf) => {
+                expect(orderbook.calculateInitialMarginFractionWithOverride({
+                    baseQuantity: (0, _pipmath_1.decimalToPip)(baseQuantity),
+                    initialMarginFractionOverride: null,
+                    leverageParameters: defaultLeverageParameters,
+                })).to.eql((0, _pipmath_1.decimalToPip)(expectedImf));
+            };
+            runScenario('1', '0.03');
+            runScenario('-1', '0.03');
+            runScenario('1000', '0.03');
+            runScenario('1001', '0.04');
+            runScenario('1100', '0.04');
+            runScenario('1101', '0.05');
+        });
+        it('should use an IMF override, if larger', () => {
+            const runScenario = (baseQuantity, initialMarginFractionOverride, expectedImf) => {
+                expect(orderbook.calculateInitialMarginFractionWithOverride({
+                    baseQuantity: (0, _pipmath_1.decimalToPip)(baseQuantity),
+                    initialMarginFractionOverride: (0, _pipmath_1.decimalToPip)(initialMarginFractionOverride),
+                    leverageParameters: defaultLeverageParameters,
+                })).to.eql((0, _pipmath_1.decimalToPip)(expectedImf));
+            };
+            runScenario('1', '0.02', '0.03');
+            runScenario('1', '0.03', '0.03');
+            runScenario('1', '0.04', '0.04');
+            runScenario('1000', '0.04', '0.04');
+            runScenario('1001', '0.04', '0.04');
+            runScenario('1101', '0.04', '0.05');
+        });
+    });
+});

package/dist/tests/orderbook/quantities/calculateMaximumInitialMarginFractionOverride.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=calculateMaximumInitialMarginFractionOverride.test.d.ts.map

package/dist/tests/orderbook/quantities/calculateMaximumInitialMarginFractionOverride.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateMaximumInitialMarginFractionOverride.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/orderbook/quantities/calculateMaximumInitialMarginFractionOverride.test.ts"],"names":[],"mappings":""}

package/dist/tests/orderbook/quantities/calculateMaximumInitialMarginFractionOverride.test.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chai = tslib_1.__importStar(require("chai"));
+const quantities_1 = require("#orderbook/quantities");
+const { expect } = chai;
+const market = {
+    market: 'DIL-USD',
+    type: 'perpetual',
+    status: 'active',
+    baseAsset: 'DIL',
+    quoteAsset: 'USD',
+    stepSize: '0.00000100',
+    tickSize: '0.00000100',
+    indexPrice: '100.00000000',
+    indexPrice24h: '100.00000000',
+    indexPricePercentChange: '0.00000000',
+    lastFundingRate: null,
+    currentFundingRate: null,
+    nextFundingTime: 1730246400000,
+    makerOrderMinimum: '0.10000000',
+    takerOrderMinimum: '0.05000000',
+    marketOrderExecutionPriceLimit: '0.10000000',
+    limitOrderExecutionPriceLimit: '0.40000000',
+    minimumPositionSize: '0.00070000',
+    maximumPositionSize: '10.00000000',
+    initialMarginFraction: '0.10000000',
+    maintenanceMarginFraction: '0.03000000',
+    basePositionSize: '1.00000000',
+    incrementalPositionSize: '0.10000000',
+    incrementalInitialMarginFraction: '0.01000000',
+    makerFeeRate: '0.00000000',
+    takerFeeRate: '0.00000000',
+    volume24h: '0.00000000',
+    trades24h: 0,
+    openInterest: '10.10000000',
+    default: true,
+};
+const wallet = {
+    wallet: '0x36915BE02C6E9B3A7FFa342Cfb81C080DC48e0Ab',
+    equity: '100.00000000',
+    freeCollateral: '40.00000000',
+    heldCollateral: '10.00000000',
+    availableCollateral: '30.00000000',
+    buyingPower: '30.00000000',
+    leverage: '5.00000000',
+    marginRatio: '0.20000000',
+    quoteBalance: '200.00000000',
+    unrealizedPnL: '0.00000000',
+    makerFeeRate: '0.00000000',
+    takerFeeRate: '0.00000000',
+    positions: [
+        {
+            market: 'DIL-USD',
+            quantity: '2.00000000',
+            maximumQuantity: '2.00000000',
+            entryPrice: '100.00000000',
+            exitPrice: '100.00000000',
+            markPrice: '0.00000000',
+            indexPrice: '100.00000000',
+            liquidationPrice: '100.00000000',
+            value: '200.00000000',
+            realizedPnL: '0.00000000',
+            unrealizedPnL: '0.00000000',
+            marginRequirement: '6.00000000',
+            leverage: '5.00000000',
+            totalFunding: '0.00000000',
+            totalOpen: '2.00000000',
+            totalClose: '0.00000000',
+            adlQuintile: 1,
+            openedByFillId: '27ec3e9b-cae0-3473-b68a-b170866be302',
+            lastFillId: '772f1c53-782e-3f13-9660-2e331831bbd7',
+            time: 1729622134888,
+        },
+    ],
+};
+describe('orderbook/quantities', () => {
+    describe('calculateInitialMarginFractionWithOverride', () => {
+        it('should succeed', () => {
+            expect((0, quantities_1.calculateMaximumInitialMarginFractionOverride)(market, wallet, [])).to.eql('0.20000000');
+            expect((0, quantities_1.calculateMaximumInitialMarginFractionOverride)(market, wallet, [
+                {
+                    wallet: wallet.wallet,
+                    market: market.market,
+                    initialMarginFractionOverride: null,
+                },
+            ])).to.eql('0.20000000');
+            expect((0, quantities_1.calculateMaximumInitialMarginFractionOverride)(market, wallet, [
+                {
+                    wallet: wallet.wallet,
+                    market: market.market,
+                    initialMarginFractionOverride: '0.20000000',
+                },
+            ])).to.eql('0.32000000');
+            const walletWithShortPosition = { ...wallet };
+            walletWithShortPosition.positions[0].quantity = '-2.00000000';
+            expect((0, quantities_1.calculateMaximumInitialMarginFractionOverride)(market, walletWithShortPosition, [
+                {
+                    wallet: wallet.wallet,
+                    market: market.market,
+                    initialMarginFractionOverride: '0.20000000',
+                },
+            ])).to.eql('0.32000000');
+            const walletWithoutPositions = { ...wallet, positions: undefined };
+            expect((0, quantities_1.calculateMaximumInitialMarginFractionOverride)(market, walletWithoutPositions, [])).to.eql('0.40000000');
+            expect((0, quantities_1.calculateMaximumInitialMarginFractionOverride)(market, walletWithoutPositions, [
+                {
+                    wallet: wallet.wallet,
+                    market: market.market,
+                    initialMarginFractionOverride: '0.20000000',
+                },
+            ])).to.eql('0.80000000');
+        });
+        const walletWithoutPositionsOrHeldCollateral = {
+            ...wallet,
+            freeCollateral: '100.00000000',
+            heldCollateral: '0.00000000',
+            positions: undefined,
+        };
+        expect((0, quantities_1.calculateMaximumInitialMarginFractionOverride)(market, walletWithoutPositionsOrHeldCollateral, [])).to.eql('1.00000000');
+    });
+});

package/dist/tests/orderbook/quantities/determineMaximumReduceOnlyQuantityAvailableAtPriceLevel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=determineMaximumReduceOnlyQuantityAvailableAtPriceLevel.test.d.ts.map

package/dist/tests/orderbook/quantities/determineMaximumReduceOnlyQuantityAvailableAtPriceLevel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"determineMaximumReduceOnlyQuantityAvailableAtPriceLevel.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/orderbook/quantities/determineMaximumReduceOnlyQuantityAvailableAtPriceLevel.test.ts"],"names":[],"mappings":""}