@katanaperps/katana-perps-sdk 0.0.0-placeholder

package/dist/bridge/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/bridge/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,eAAO,MAAM,kBAAkB,qPAA8B,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Kf,CAAC;AAEX,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC7C,CAAC;AAEF;;;;;;;GAOG;AAEH,wBAAgB,mBAAmB,CAEjC,KAAK,EAAE,GAAG,GACT,KAAK,IAAI,YAAY,CAEvB"}

package/dist/bridge/config.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidBridgeTarget = exports.BridgeConfigByLayerZeroEndpointId = exports.BridgeConfig = exports.BridgeTargetsArray = void 0;
+const request_1 = require("#types/enums/request");
+exports.BridgeTargetsArray = Object.values(request_1.BridgeTarget);
+/**
+ * TODO_IKON - These configs need to be completed in some areas and should be confirmed as valid
+ *
+ * @see [evmChainId](https://gist.github.com/melwong/c30eb1e21eda17549996a609c35dafb3#file-list-of-chain-ids-for-metamask-csv)
+ *
+ * @category Stargate
+ */
+exports.BridgeConfig = {
+    settings: {
+        addManagedAccountExtraGas: 300_000,
+        depositSourceChainGasLimit: 450_000,
+        stargateBridgeForwarderGasLimit: 450_000,
+        localBridgeTarget: request_1.BridgeTarget.KATANA_KATANA,
+    },
+    mainnet: {
+        [request_1.BridgeTarget.KATANA_KATANA]: {
+            target: request_1.BridgeTarget.KATANA_KATANA,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=katana
+            evmChainId: 747474,
+            layerZeroEndpointId: 30375,
+            // No USDC OFT currently supported on Katana
+            layerzeroOFTAddress: '0x0000000000000000000000000000000000000000',
+            // vbUSDC
+            tokenDecimals: 6,
+            usdcAddress: '0x203a662b0bd271a6ed5a60edfbd04bfce608fd36',
+        },
+        [request_1.BridgeTarget.LAYERZERO_BERACHAIN]: {
+            target: request_1.BridgeTarget.LAYERZERO_BERACHAIN,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=bera
+            evmChainId: 80094,
+            layerZeroEndpointId: 30362,
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/mainnet-contracts#berachain
+            layerzeroOFTAddress: '0xAF54BE5B6eEc24d6BFACf1cce4eaF680A8239398',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#bera
+            tokenDecimals: 6,
+            usdcAddress: '0x549943e04f40284185054145c6E4e9568C1D3241',
+        },
+        [request_1.BridgeTarget.STARGATE_ARBITRUM]: {
+            target: request_1.BridgeTarget.STARGATE_ARBITRUM,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=arbitrum
+            evmChainId: 42161,
+            layerZeroEndpointId: 30110,
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/mainnet-contracts#arbitrum
+            layerzeroOFTAddress: '0xe8CDF27AcD73a434D661C84887215F7598e7d0d3',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#arbitrum
+            tokenDecimals: 6,
+            usdcAddress: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        },
+        [request_1.BridgeTarget.STARGATE_AURORA]: {
+            target: request_1.BridgeTarget.STARGATE_AURORA,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=aurora
+            evmChainId: 1313161554,
+            layerZeroEndpointId: 30211,
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/mainnet-contracts#aurora
+            layerzeroOFTAddress: '0x81F6138153d473E8c5EcebD3DC8Cd4903506B075',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#aurora
+            tokenDecimals: 6,
+            usdcAddress: '0x368EBb46ACa6b8D0787C96B2b20bD3CC3F2c45F7',
+        },
+        [request_1.BridgeTarget.STARGATE_AVALANCHE]: {
+            target: request_1.BridgeTarget.STARGATE_AVALANCHE,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=avalanche
+            evmChainId: 43114,
+            layerZeroEndpointId: 30106,
+            // https://stargateprotocol.gitbook.io/stargate/v/v2-developer-docs/technical-reference/mainnet-contracts#avalanche
+            layerzeroOFTAddress: '0x5634c4a5FEd09819E3c46D86A965Dd9447d86e47',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#avalanche
+            tokenDecimals: 6,
+            usdcAddress: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
+        },
+        [request_1.BridgeTarget.STARGATE_BASE]: {
+            target: request_1.BridgeTarget.STARGATE_BASE,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=base
+            evmChainId: 8453,
+            layerZeroEndpointId: 30184,
+            // https://stargateprotocol.gitbook.io/stargate/v/v2-developer-docs/technical-reference/mainnet-contracts#base
+            layerzeroOFTAddress: '0x27a16dc786820B16E5c9028b75B99F6f604b5d26',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#base
+            tokenDecimals: 6,
+            usdcAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+        },
+        [request_1.BridgeTarget.STARGATE_BNB]: {
+            target: request_1.BridgeTarget.STARGATE_BNB,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=bnb
+            evmChainId: 56,
+            layerZeroEndpointId: 30102,
+            // https://stargateprotocol.gitbook.io/stargate/v/v2-developer-docs/technical-reference/mainnet-contracts#bnb-chain
+            layerzeroOFTAddress: '0x962Bd449E630b0d928f308Ce63f1A21F02576057',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#bnb
+            tokenDecimals: 18,
+            usdcAddress: '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d',
+        },
+        [request_1.BridgeTarget.STARGATE_ETHEREUM]: {
+            target: request_1.BridgeTarget.STARGATE_ETHEREUM,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=ethereum
+            evmChainId: 1,
+            layerZeroEndpointId: 30101,
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/mainnet-contracts#ethereum
+            layerzeroOFTAddress: '0xc026395860Db2d07ee33e05fE50ed7bD583189C7',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#ethereum
+            tokenDecimals: 6,
+            usdcAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        },
+        [request_1.BridgeTarget.STARGATE_OPTIMISM]: {
+            target: request_1.BridgeTarget.STARGATE_OPTIMISM,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=optimism
+            evmChainId: 10,
+            layerZeroEndpointId: 30111,
+            // https://stargateprotocol.gitbook.io/stargate/v/v2-developer-docs/technical-reference/mainnet-contracts#optimism
+            layerzeroOFTAddress: '0xcE8CcA271Ebc0533920C83d39F417ED6A0abB7D0',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#optimism
+            tokenDecimals: 6,
+            usdcAddress: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
+        },
+        [request_1.BridgeTarget.STARGATE_RARI]: {
+            target: request_1.BridgeTarget.STARGATE_RARI,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=rarible
+            evmChainId: 1380012617,
+            layerZeroEndpointId: 30235,
+            // https://stargateprotocol.gitbook.io/stargate/v/v2-developer-docs/technical-reference/mainnet-contracts#rari
+            layerzeroOFTAddress: '0x875bee36739e7Ce6b60E056451c556a88c59b086',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#rari-chain
+            tokenDecimals: 6,
+            usdcAddress: '0xFbDa5F676cB37624f28265A144A48B0d6e87d3b6',
+        },
+        [request_1.BridgeTarget.STARGATE_SCROLL]: {
+            target: request_1.BridgeTarget.STARGATE_SCROLL,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=scroll
+            evmChainId: 534352,
+            layerZeroEndpointId: 30214,
+            // https://stargateprotocol.gitbook.io/stargate/v/v2-developer-docs/technical-reference/mainnet-contracts#scroll
+            layerzeroOFTAddress: '0x3Fc69CC4A842838bCDC9499178740226062b14E4',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#scroll
+            tokenDecimals: 6,
+            usdcAddress: '0x06eFdBFf2a14a7c8E15944D1F4A48F9F95F663A4',
+        },
+        [request_1.BridgeTarget.STARGATE_TAIKO]: {
+            target: request_1.BridgeTarget.STARGATE_TAIKO,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=taiko
+            evmChainId: 167000,
+            layerZeroEndpointId: 30290,
+            // https://stargateprotocol.gitbook.io/stargate/v/v2-developer-docs/technical-reference/mainnet-contracts#taiko
+            layerzeroOFTAddress: '0x77C71633C34C3784ede189d74223122422492a0f',
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/v2-supported-networks-and-assets#taiko
+            tokenDecimals: 6,
+            usdcAddress: '0x19e26B0638bf63aa9fa4d14c6baF8D52eBE86C5C',
+        },
+    },
+    testnet: {
+        [request_1.BridgeTarget.KATANA_KATANA]: {
+            target: request_1.BridgeTarget.KATANA_KATANA,
+            isSupported: true,
+            evmChainId: 64002,
+            layerZeroEndpointId: 40282,
+            layerzeroOFTAddress: '0x54a04EfABCBd81A0488E4a9Ad22264E04A48329B',
+            tokenDecimals: 6,
+            usdcAddress: '0x54a04EfABCBd81A0488E4a9Ad22264E04A48329B',
+        },
+        [request_1.BridgeTarget.LAYERZERO_BERACHAIN]: {
+            target: request_1.BridgeTarget.LAYERZERO_BERACHAIN,
+            // TODO There is currently no testnet for Berachain so we are using
+            // Sepolia as a substitute for testing purposes
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=sepolia
+            evmChainId: 11155111,
+            layerZeroEndpointId: 40161,
+            layerzeroOFTAddress: '0x21F1caDDBED3Cd50e6B30644459BFB80c367076c',
+            tokenDecimals: 6,
+            usdcAddress: '0x2F6F07CDcf3588944Bf4C42aC74ff24bF56e7590',
+        },
+        [request_1.BridgeTarget.STARGATE_ARBITRUM]: {
+            target: request_1.BridgeTarget.STARGATE_ARBITRUM,
+            // https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=arbitrum-sepolia
+            evmChainId: 421614,
+            layerZeroEndpointId: 40231,
+            // https://stargateprotocol.gitbook.io/stargate/v2-developer-docs/technical-reference/testnet-contracts#arbitrum-sepolia-testnet
+            layerzeroOFTAddress: '0x543BdA7c6cA4384FE90B1F5929bb851F52888983',
+            tokenDecimals: 6,
+            usdcAddress: '0x3253a335E7bFfB4790Aa4C25C4250d206E9b9773',
+        },
+    },
+};
+exports.BridgeConfigByLayerZeroEndpointId = {
+    mainnet: {
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.LAYERZERO_BERACHAIN]
+            .layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.LAYERZERO_BERACHAIN],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_ARBITRUM].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_ARBITRUM],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_AURORA].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_AURORA],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_AVALANCHE].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_AVALANCHE],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_BASE].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_BASE],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_BNB].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_BNB],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_ETHEREUM].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_ETHEREUM],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_OPTIMISM].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_OPTIMISM],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_RARI].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_RARI],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_SCROLL].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_SCROLL],
+        [exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_TAIKO].layerZeroEndpointId]: exports.BridgeConfig.mainnet[request_1.BridgeTarget.STARGATE_TAIKO],
+    },
+    testnet: {
+        [exports.BridgeConfig.testnet[request_1.BridgeTarget.LAYERZERO_BERACHAIN]
+            .layerZeroEndpointId]: exports.BridgeConfig.testnet[request_1.BridgeTarget.LAYERZERO_BERACHAIN],
+        [exports.BridgeConfig.testnet[request_1.BridgeTarget.STARGATE_ARBITRUM].layerZeroEndpointId]: exports.BridgeConfig.testnet[request_1.BridgeTarget.STARGATE_ARBITRUM],
+    },
+};
+/**
+ * A type guard that checks if the given value is a valid {@link BridgeTarget} value.
+ *
+ * - This will not validate that the value is a {@link BridgeTarget} as that is  a subset of
+ *   {@link BridgeTarget}, use {@link isValidBridgeTarget} for that.
+ *
+ * @internal
+ */
+function isValidBridgeTarget(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+value) {
+    return value && exports.BridgeTargetsArray.includes(value);
+}
+exports.isValidBridgeTarget = isValidBridgeTarget;

package/dist/bridge/deposit.d.ts

@@ -0,0 +1,107 @@
+import { ethers, type TransactionRequest } from 'ethers';
+import { BridgeTarget } from '#types/enums/request';
+import { getBridgeTargetConfig } from './utils';
+import type { Expand } from '../types/utils';
+export declare enum DepositBridgeAdapterPayloadType {
+    addManagedAccount = 0,
+    depositToManagedAccount = 1,
+    depositToWallet = 2
+}
+export type AddManagedAccountBridgePayloadParameters = {
+    fixedIncomeVaultProviderAddress: string;
+    managerWallet: string;
+    addManagedAccountPayload: string;
+};
+export type DepositToManagedAccountBridgePayloadParameters = {
+    depositorWallet: string;
+    fixedIncomeVaultProviderAddress: string;
+    managerWallet: string;
+};
+export type DepositToWalletBridgePayloadParameters = {
+    depositorWallet: string;
+};
+export type DepositBaseParameters = {
+    exchangeLayerZeroAdapterAddress?: string;
+    minimumForwardQuantityMultiplierInPips: bigint;
+    quantityInAssetUnits: bigint;
+    sourceBridgeTarget: BridgeTarget;
+    stargateBridgeForwarderContractAddress?: string;
+    bridgePayloadType: DepositBridgeAdapterPayloadType;
+};
+export type AddManagedAccountParameters = Expand<DepositBaseParameters & {
+    bridgePayloadType: DepositBridgeAdapterPayloadType.addManagedAccount;
+} & AddManagedAccountBridgePayloadParameters>;
+export type DepositToManagedAccountParameters = Expand<DepositBaseParameters & {
+    bridgePayloadType: DepositBridgeAdapterPayloadType.depositToManagedAccount;
+} & DepositToManagedAccountBridgePayloadParameters>;
+export type DepositToWalletParameters = Expand<DepositBaseParameters & {
+    bridgePayloadType: DepositBridgeAdapterPayloadType.depositToWallet;
+} & DepositToWalletBridgePayloadParameters>;
+/**
+ * Encoded withdrawal bridge payload
+ */
+export type EncodedDepositBridgeAdapterPayload = string;
+export type FixedIncomeVaultConfigurationFields = {
+    managerWallet: string;
+    effectiveTimestampInS: number;
+    interestMultiplierInPips: bigint;
+    maximumNetDepositsInPips: bigint;
+    maximumTotalOwedQuantityAvailableForExitWithdrawalMultiplierNeededToInitiateExitInPips: bigint;
+    minimumTotalOwedQuantityAvailableForExitWithdrawalMultiplierToAllowManagerWalletWithdrawalInPips: bigint;
+    minimumUnappliedWithdrawalAgeInSNeededToInitiateExit: number;
+    withdrawalLimitPercentForDepositorsInPips: bigint;
+    withdrawalLimitPercentForVaultInPips: bigint;
+};
+export declare const fixedIncomeVaultConfigurationFieldsLength: number;
+export declare const depositBridgeAdapterPayloadLengths: {
+    0: number;
+    1: number;
+    2: number;
+};
+export declare function decodeDepositBridgeAdapterPayloadType(payload: EncodedDepositBridgeAdapterPayload): number;
+export declare function decodeDepositBridgeAdapterPayload(payload: EncodedDepositBridgeAdapterPayload): {
+    bridgePayloadType: DepositBridgeAdapterPayloadType;
+    sourceEndpointId: any;
+    managedAccountProvider: any;
+    managerWallet: any;
+    addManagedAccountPayload: any;
+    depositPayload: any;
+    depositorWallet?: undefined;
+} | {
+    bridgePayloadType: DepositBridgeAdapterPayloadType;
+    sourceEndpointId: any;
+    depositorWallet: any;
+    managedAccountProvider: any;
+    managerWallet: any;
+    depositPayload: any;
+    addManagedAccountPayload?: undefined;
+} | {
+    bridgePayloadType: DepositBridgeAdapterPayloadType;
+    sourceEndpointId: any;
+    depositorWallet: any;
+    managedAccountProvider?: undefined;
+    managerWallet?: undefined;
+    addManagedAccountPayload?: undefined;
+    depositPayload?: undefined;
+} | undefined;
+/**
+ * Deposit funds cross-chain into the Exchange using a LayerZero OFT or Stargate
+ */
+export declare function depositViaBridge(parameters: AddManagedAccountParameters | DepositToManagedAccountParameters | DepositToWalletParameters, providers: {
+    berachain: ethers.Provider;
+    sourceChain: ethers.Provider;
+}, sourceSigner: ethers.Signer, sandbox: boolean, extraRequestParams?: Pick<TransactionRequest, 'nonce'>): Promise<string>;
+export declare function encodeDepositBridgeAdapterPayload(sourceConfig: ReturnType<typeof getBridgeTargetConfig>, parameters: AddManagedAccountParameters | DepositToManagedAccountParameters | DepositToWalletParameters): EncodedDepositBridgeAdapterPayload;
+export declare function encodeFixedIncomeVaultConfigurationFields(configurationFields: FixedIncomeVaultConfigurationFields): string;
+/**
+ * Estimate native gas fee needed to deposit USDC cross-chain into the Exchange
+ */
+export declare function estimateDepositFees(parameters: AddManagedAccountParameters | DepositToManagedAccountParameters | DepositToWalletParameters, providers: {
+    berachain: ethers.Provider;
+    sourceChain: ethers.Provider;
+}, sandbox: boolean): Promise<{
+    gasFee: bigint;
+    quantityDeliveredInAssetUnits: bigint;
+}>;
+export declare function getDestinationWallet(parameters: AddManagedAccountParameters | DepositToManagedAccountParameters | DepositToWalletParameters): string;
+//# sourceMappingURL=deposit.d.ts.map

package/dist/bridge/deposit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deposit.d.ts","sourceRoot":"","sources":["../../src/bridge/deposit.ts"],"names":[],"mappings":"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"}

package/dist/bridge/deposit.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDestinationWallet = exports.estimateDepositFees = exports.encodeFixedIncomeVaultConfigurationFields = exports.encodeDepositBridgeAdapterPayload = exports.depositViaBridge = exports.decodeDepositBridgeAdapterPayload = exports.decodeDepositBridgeAdapterPayloadType = exports.depositBridgeAdapterPayloadLengths = exports.fixedIncomeVaultConfigurationFieldsLength = exports.DepositBridgeAdapterPayloadType = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+const _pipmath_1 = require("#pipmath");
+const config_1 = require("#bridge/config");
+const index_1 = require("#typechain-types/index");
+const request_1 = require("#types/enums/request");
+const utils_1 = require("./utils");
+var DepositBridgeAdapterPayloadType;
+(function (DepositBridgeAdapterPayloadType) {
+    DepositBridgeAdapterPayloadType[DepositBridgeAdapterPayloadType["addManagedAccount"] = 0] = "addManagedAccount";
+    DepositBridgeAdapterPayloadType[DepositBridgeAdapterPayloadType["depositToManagedAccount"] = 1] = "depositToManagedAccount";
+    DepositBridgeAdapterPayloadType[DepositBridgeAdapterPayloadType["depositToWallet"] = 2] = "depositToWallet";
+})(DepositBridgeAdapterPayloadType || (exports.DepositBridgeAdapterPayloadType = DepositBridgeAdapterPayloadType = {}));
+exports.fixedIncomeVaultConfigurationFieldsLength = 32 + 32 + 32 + 32 + 32 + 32 + 32 + 32 + 32 + 32; // tuple header + address + uint64 + uint64 + uint64 + uint64 + uint64 + uint64 + uint64 + uint64
+exports.depositBridgeAdapterPayloadLengths = {
+    [DepositBridgeAdapterPayloadType.addManagedAccount]: 32 + 32 + 32 + 32 + 32 + 32 + exports.fixedIncomeVaultConfigurationFieldsLength, // uint8 + tuple header + uint32 + address + address + bytes length + bytes
+    [DepositBridgeAdapterPayloadType.depositToManagedAccount]: 32 + 32 + 32 + 32 + 32 + 32 + 32 + 32, // uint8 + tuple header + uint32 + address + address + address + bytes length + bytes
+    [DepositBridgeAdapterPayloadType.depositToWallet]: 32 + 32 + 32, // uint8 + uint32 + address
+};
+function decodeDepositBridgeAdapterPayloadType(payload) {
+    return parseInt(ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(['uint8'], payload)[0], 10);
+}
+exports.decodeDepositBridgeAdapterPayloadType = decodeDepositBridgeAdapterPayloadType;
+function decodeDepositBridgeAdapterPayload(payload) {
+    const bridgePayloadType = decodeDepositBridgeAdapterPayloadType(payload);
+    if (bridgePayloadType === DepositBridgeAdapterPayloadType.addManagedAccount) {
+        const [, [sourceEndpointId, managedAccountProvider, managerWallet, addManagedAccountPayload, depositPayload,],] = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(['uint8', 'tuple(uint32,address,address,bytes,bytes)'], payload);
+        return {
+            bridgePayloadType,
+            sourceEndpointId,
+            managedAccountProvider,
+            managerWallet,
+            addManagedAccountPayload,
+            depositPayload,
+        };
+    }
+    if (bridgePayloadType ===
+        DepositBridgeAdapterPayloadType.depositToManagedAccount) {
+        const [, [sourceEndpointId, depositorWallet, managedAccountProvider, managerWallet, depositPayload,],] = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(['uint8', 'tuple(uint32,address,address,address,bytes)'], payload);
+        return {
+            bridgePayloadType,
+            sourceEndpointId,
+            depositorWallet,
+            managedAccountProvider,
+            managerWallet,
+            depositPayload,
+        };
+    }
+    if (bridgePayloadType === DepositBridgeAdapterPayloadType.depositToWallet) {
+        const [, [sourceEndpointId, depositorWallet]] = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(['uint8', 'tuple(uint32,address)'], payload);
+        return {
+            bridgePayloadType,
+            sourceEndpointId,
+            depositorWallet,
+        };
+    }
+    return undefined;
+}
+exports.decodeDepositBridgeAdapterPayload = decodeDepositBridgeAdapterPayload;
+/**
+ * Deposit funds cross-chain into the Exchange using a LayerZero OFT or Stargate
+ */
+async function depositViaBridge(parameters, providers, sourceSigner, sandbox, extraRequestParams) {
+    const [{ sendParam, sourceConfig }, { gasFee }] = await Promise.all(parameters.sourceBridgeTarget === request_1.BridgeTarget.LAYERZERO_BERACHAIN ?
+        [
+            getDepositFromBerachainSendParamAndSourceConfig(parameters, sandbox),
+            estimateDepositFromBerachainFees(parameters, providers, sandbox),
+        ]
+        : [
+            getDepositViaForwarderSendParamAndSourceConfig(parameters, providers, sandbox),
+            estimateDepositViaForwarderFees(parameters, providers, sandbox),
+        ]);
+    let gasLimit = config_1.BridgeConfig.settings.depositSourceChainGasLimit;
+    const oft = index_1.IOFT__factory.connect(sourceConfig.layerzeroOFTAddress, sourceSigner);
+    const wallet = getDestinationWallet(parameters);
+    try {
+        // Estimate gas
+        const estimatedGasLimit = await oft.send.estimateGas(sendParam, { nativeFee: gasFee, lzTokenFee: 0 }, wallet, // Refund address - extra gas (if any) is returned to this address
+        {
+            ...extraRequestParams,
+            from: wallet,
+            // Native gas to pay for the cross chain message fee
+            value: gasFee,
+        });
+        // Add 20% buffer for safety
+        gasLimit = Number(new bignumber_js_1.default(estimatedGasLimit.toString())
+            .times(new bignumber_js_1.default(1.2))
+            .toFixed(0));
+    }
+    catch (error) {
+        // ethers.js will perform the estimation at the block gas limit, which is much higher than the
+        // gas actually needed by the tx. If the wallet does not have the funds to cover the tx at this
+        // high gas limit then the RPC will throw an INSUFFICIENT_FUNDS error; however the wallet may
+        // still have enough funds to successfully bridge at the actual gas limit. In this case simply
+        // fall through and use the configured default gas limit. The wallet software in use should
+        // still show if that limit is insufficient, which is only an issue for blockchains with
+        // variable gas costs such as Arbitrum One
+        if (!error.code || error.code !== 'INSUFFICIENT_FUNDS') {
+            throw error;
+        }
+    }
+    const response = await oft.send(sendParam, { nativeFee: gasFee, lzTokenFee: 0 }, wallet, // Refund address - extra gas (if any) is returned to this address
+    {
+        from: wallet,
+        gasLimit,
+        value: gasFee,
+    });
+    return response.hash;
+}
+exports.depositViaBridge = depositViaBridge;
+function encodeDepositBridgeAdapterPayload(sourceConfig, parameters) {
+    if (parameters.bridgePayloadType ===
+        DepositBridgeAdapterPayloadType.addManagedAccount) {
+        return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['uint8', 'tuple(uint32,address,address,bytes,bytes)'], [
+            DepositBridgeAdapterPayloadType.addManagedAccount,
+            [
+                sourceConfig.layerZeroEndpointId,
+                parameters.fixedIncomeVaultProviderAddress,
+                parameters.managerWallet,
+                parameters.addManagedAccountPayload,
+                '0x',
+            ],
+        ]);
+    }
+    if (parameters.bridgePayloadType ===
+        DepositBridgeAdapterPayloadType.depositToManagedAccount) {
+        return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['uint8', 'tuple(uint32,address,address,address,bytes)'], [
+            DepositBridgeAdapterPayloadType.depositToManagedAccount,
+            [
+                sourceConfig.layerZeroEndpointId,
+                parameters.depositorWallet,
+                parameters.fixedIncomeVaultProviderAddress,
+                parameters.managerWallet,
+                '0x', // depositPayload
+            ],
+        ]);
+    }
+    if (parameters.bridgePayloadType ===
+        DepositBridgeAdapterPayloadType.depositToWallet) {
+        return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['uint8', 'tuple(uint32,address)'], [
+            DepositBridgeAdapterPayloadType.depositToWallet,
+            [sourceConfig.layerZeroEndpointId, parameters.depositorWallet],
+        ]);
+    }
+    throw new Error(`Invalid bridge payload type ${parameters.bridgePayloadType}`);
+}
+exports.encodeDepositBridgeAdapterPayload = encodeDepositBridgeAdapterPayload;
+function encodeFixedIncomeVaultConfigurationFields(configurationFields) {
+    return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['tuple(address,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)'], [
+        [
+            configurationFields.managerWallet,
+            configurationFields.effectiveTimestampInS,
+            configurationFields.interestMultiplierInPips,
+            configurationFields.maximumNetDepositsInPips,
+            configurationFields.maximumTotalOwedQuantityAvailableForExitWithdrawalMultiplierNeededToInitiateExitInPips,
+            configurationFields.minimumTotalOwedQuantityAvailableForExitWithdrawalMultiplierToAllowManagerWalletWithdrawalInPips,
+            configurationFields.minimumUnappliedWithdrawalAgeInSNeededToInitiateExit,
+            configurationFields.withdrawalLimitPercentForDepositorsInPips,
+            configurationFields.withdrawalLimitPercentForVaultInPips,
+        ],
+    ]);
+}
+exports.encodeFixedIncomeVaultConfigurationFields = encodeFixedIncomeVaultConfigurationFields;
+/**
+ * Estimate native gas fee needed to deposit USDC cross-chain into the Exchange
+ */
+async function estimateDepositFees(parameters, providers, sandbox) {
+    if (parameters.sourceBridgeTarget === request_1.BridgeTarget.LAYERZERO_BERACHAIN) {
+        return estimateDepositFromBerachainFees(parameters, providers, sandbox);
+    }
+    return estimateDepositViaForwarderFees(parameters, providers, sandbox);
+}
+exports.estimateDepositFees = estimateDepositFees;
+function getDestinationWallet(parameters) {
+    if (parameters.bridgePayloadType ===
+        DepositBridgeAdapterPayloadType.addManagedAccount) {
+        return parameters.managerWallet;
+    }
+    if (parameters.bridgePayloadType ===
+        DepositBridgeAdapterPayloadType.depositToManagedAccount ||
+        parameters.bridgePayloadType ===
+            DepositBridgeAdapterPayloadType.depositToWallet) {
+        return parameters.depositorWallet;
+    }
+    throw new Error(`Invalid bridge payload type ${parameters.bridgePayloadType}`);
+}
+exports.getDestinationWallet = getDestinationWallet;
+/**
+ * Estimate native gas fee needed to deposit USDC cross-chain into the Exchange
+ * from Berachain using the OFT pathway
+ */
+async function estimateDepositFromBerachainFees(parameters, providers, sandbox) {
+    const { sendParam, sourceConfig } = await getDepositFromBerachainSendParamAndSourceConfig(parameters, sandbox);
+    const oft = index_1.IOFT__factory.connect(sourceConfig.layerzeroOFTAddress, providers.berachain);
+    const [[gasFee], [, , receipt]] = await Promise.all([
+        oft.quoteSend(sendParam, false, {
+            from: getDestinationWallet(parameters),
+        }),
+        oft.quoteOFT(sendParam),
+    ]);
+    return {
+        gasFee,
+        quantityDeliveredInAssetUnits: receipt.amountReceivedLD,
+    };
+}
+async function estimateDepositViaForwarderFees(parameters, providers, sandbox) {
+    const { sendParam, sourceConfig } = await getDepositViaForwarderSendParamAndSourceConfig(parameters, providers, sandbox);
+    const ioft = index_1.IOFT__factory.connect(sourceConfig.layerzeroOFTAddress, providers.sourceChain);
+    const [{ nativeFee: gasFee }, [, , receipt]] = await Promise.all([
+        ioft.quoteSend(sendParam, false, {
+            from: getDestinationWallet(parameters),
+        }),
+        ioft.quoteOFT(sendParam),
+    ]);
+    // Once we obtain the quantity delivered after slippage to Berachain, calculate
+    // the quantity subsequently delivered to Katana after any additional slippage
+    const { quantityDeliveredInAssetUnits } = await estimateDepositFromBerachainFees({ ...parameters, quantityInAssetUnits: receipt.amountReceivedLD }, providers, sandbox);
+    return {
+        gasFee,
+        quantityDeliveredInAssetUnits,
+    };
+}
+async function getDepositFromBerachainSendParamAndSourceConfig(parameters, sandbox) {
+    const { sourceConfig, destinationConfig } = getSourceAndDestinationConfigs(request_1.BridgeTarget.LAYERZERO_BERACHAIN, request_1.BridgeTarget.KATANA_KATANA, sandbox);
+    const exchangeLayerZeroAdapterAddress = await (0, utils_1.loadExchangeLayerZeroAddressFromApiIfNeeded)(parameters.exchangeLayerZeroAdapterAddress);
+    let extraOptions = new Uint8Array();
+    if (parameters.bridgePayloadType ===
+        DepositBridgeAdapterPayloadType.addManagedAccount) {
+        const { Options } = await import('@layerzerolabs/lz-v2-utilities');
+        extraOptions = Options.newOptions()
+            .addExecutorComposeOption(0, config_1.BridgeConfig.settings.addManagedAccountExtraGas, 0)
+            .toBytes();
+    }
+    const sendParam = {
+        dstEid: destinationConfig.layerZeroEndpointId, // Destination endpoint ID
+        to: ethers_1.ethers.zeroPadValue(exchangeLayerZeroAdapterAddress, 32), // Recipient address
+        amountLD: parameters.quantityInAssetUnits, // Amount to send in local decimals
+        minAmountLD: (0, _pipmath_1.multiplyPips)(parameters.quantityInAssetUnits, parameters.minimumForwardQuantityMultiplierInPips), // Minimum amount to send in local decimals
+        extraOptions,
+        composeMsg: encodeDepositBridgeAdapterPayload(sourceConfig, parameters), // Additional options supplied by the caller to be used in the LayerZero message
+        oftCmd: '0x', // The OFT command to be executed, unused in default OFT implementations
+    };
+    return { sendParam, sourceConfig };
+}
+async function getDepositViaForwarderSendParamAndSourceConfig(parameters, providers, sandbox) {
+    const { sourceConfig, destinationConfig: berachainConfig } = getSourceAndDestinationConfigs(parameters.sourceBridgeTarget, request_1.BridgeTarget.LAYERZERO_BERACHAIN, sandbox);
+    const { gasFee: berachainGasFee } = await estimateDepositFromBerachainFees(parameters, providers, sandbox);
+    // Add 20% buffer for safety
+    const additionalNativeDrop = new bignumber_js_1.default(berachainGasFee.toString())
+        .times(new bignumber_js_1.default(1.2))
+        .toFixed(0);
+    const stargateBridgeForwarderContractAddress = await (0, utils_1.loadStargateBridgeForwarderContractAddressFromApiIfNeeded)(parameters.stargateBridgeForwarderContractAddress);
+    // FIXME CJS dynamic import
+    const { Options } = await import('@layerzerolabs/lz-v2-utilities');
+    const extraOptions = Options.newOptions()
+        // Native drop is specified in BERA wei
+        .addExecutorComposeOption(0, config_1.BridgeConfig.settings.stargateBridgeForwarderGasLimit, additionalNativeDrop)
+        .toHex();
+    const sendParam = {
+        dstEid: berachainConfig.layerZeroEndpointId, // Destination endpoint ID
+        to: ethers_1.ethers.zeroPadValue(stargateBridgeForwarderContractAddress, 32), // Recipient address
+        amountLD: parameters.quantityInAssetUnits, // Amount to send in local decimals
+        minAmountLD: (0, _pipmath_1.multiplyPips)(parameters.quantityInAssetUnits, parameters.minimumForwardQuantityMultiplierInPips), // Minimum amount to send in local decimals
+        extraOptions,
+        composeMsg: ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['uint8', 'tuple(address, bytes)'], [
+            0, //  ComposeMessageType.DepositToKatana
+            [
+                getDestinationWallet(parameters),
+                encodeDepositBridgeAdapterPayload(sourceConfig, parameters),
+            ],
+        ]),
+        oftCmd: '0x', // The OFT command to be executed, unused in default OFT implementations
+    };
+    return { sendParam, sourceConfig };
+}
+function getSourceAndDestinationConfigs(sourceTarget, destinationTarget, sandbox) {
+    const sourceConfig = (0, utils_1.getBridgeTargetConfig)(sourceTarget, sandbox);
+    const destinationConfig = (0, utils_1.getBridgeTargetConfig)(destinationTarget, sandbox);
+    return { sourceConfig, destinationConfig };
+}

package/dist/bridge/index.d.ts

@@ -0,0 +1,5 @@
+export * from '#bridge/config';
+export * from '#bridge/deposit';
+export * from '#bridge/utils';
+export * from '#bridge/withdraw';
+//# sourceMappingURL=index.d.ts.map

package/dist/bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bridge/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

package/dist/bridge/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("#bridge/config"), exports);
+tslib_1.__exportStar(require("#bridge/deposit"), exports);
+tslib_1.__exportStar(require("#bridge/utils"), exports);
+tslib_1.__exportStar(require("#bridge/withdraw"), exports);