@defisaver/ethena-sdk 0.0.4 → 0.0.6

package/esm/contracts.js

@@ -0,0 +1,37 @@
+import { getContract } from 'viem';
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import * as configRaw from './config/contracts';
+// @ts-ignore
+const contractConfig = configRaw;
+export const getConfigContractAddress = (name, network) => {
+    const networkData = contractConfig[name].networks[network];
+    const latestAddress = (networkData === null || networkData === void 0 ? void 0 : networkData.address) || '';
+    return latestAddress;
+};
+export const getConfigContractAbi = (name) => {
+    const latestAbi = contractConfig[name].abi;
+    return latestAbi;
+};
+export const createContractFromConfigFunc = (name, _address) => (client, network) => {
+    const address = (_address || getConfigContractAddress(name, network));
+    const abi = getConfigContractAbi(name);
+    return getContract({
+        address,
+        abi,
+        client,
+    });
+};
+export const Safe130Contract = createContractFromConfigFunc('Safe130');
+export const SafeFactoryContract = createContractFromConfigFunc('SafeProxyFactory130');
+export const MorphoManagerContract = createContractFromConfigFunc('MorphoManager');
+export const getSafeWalletContract = (client, address) => {
+    const abi = getConfigContractAbi('Safe130');
+    return getContract({
+        address,
+        abi,
+        client,
+    });
+};
+export const getSafeWalletSingletonAddress = (network) => getConfigContractAddress('Safe130', network || NetworkNumber.Eth);
+export const getSafeFactoryAddress = (network) => getConfigContractAddress('SafeProxyFactory130', network || NetworkNumber.Eth);
+export const getSafeFallbackHandlerAddress = (network) => getConfigContractAddress('SafeFallbackHandler130', network || NetworkNumber.Eth);

package/esm/exchange/index.d.ts

@@ -0,0 +1,10 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { OffchainExchanges, PriceData } from '../types';
+export declare const numStringToBytes: (num: number) => string;
+export declare const getBestPrice: (fromAsset: string, toAsset: string, amount: string, userAddress: string, network?: NetworkNumber) => Promise<PriceData>;
+export declare const getExchangeOrder: (fromAsset: string, toAsset: string, amount: string, userAddress: string, minPrice: string, network?: NetworkNumber) => Promise<{
+    orderData: (string | string[])[];
+    value: string;
+    source: OffchainExchanges | "None";
+    price: string;
+}>;

package/esm/exchange/index.js

@@ -0,0 +1,176 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import BN from 'bn.js';
+import { NetworkNumber } from '@defisaver/positions-sdk';
+import { assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
+import { OffchainExchanges } from '../types';
+import { DFS_API_URL, SLIPPAGE_PERCENT, STABLE_PAIR_FEE_DIVIDER, ZERO_ADDRESS, } from '../constants';
+const getOffchainEmptyData = (source = 'None') => ({
+    wrapper: ZERO_ADDRESS,
+    to: ZERO_ADDRESS,
+    allowanceTarget: ZERO_ADDRESS,
+    price: '0',
+    priceWithFee: '0',
+    protocolFee: '0',
+    data: '0x00',
+    value: '0',
+    gas: '0',
+    source,
+});
+const parsePriceWithDecimals = (price, fromDecimals, toDecimals) => new Dec(price)
+    .div(Math.pow(10, toDecimals))
+    .div(Math.pow(10, (18 - fromDecimals)))
+    .toString();
+const formatPriceWithDecimalForContract = (price, fromDecimals, toDecimals) => new Dec(price)
+    .mul(Math.pow(10, toDecimals))
+    .mul(Math.pow(10, (18 - fromDecimals)))
+    .floor()
+    .toString();
+const includeFeeInPrice = (price, from, to, fee) => {
+    if (from === to)
+        return price;
+    return new Dec(price).mul(new Dec(1).sub(fee)).toString();
+};
+const excludeFeeFromPrice = (price, from, to, fee) => {
+    if (from === to)
+        return price;
+    return new Dec(price).mul(new Dec(1).add(fee)).toString();
+};
+const parseOffchainPrice = (fromTokenSymbol, fromTokenDecimals, toTokenSymbol, toTokenDecimals, amount, feeDecimal) => {
+    const _price = parsePriceWithDecimals(amount, fromTokenDecimals, toTokenDecimals);
+    return includeFeeInPrice(_price, fromTokenSymbol, toTokenSymbol, feeDecimal);
+};
+const getFeeDecimal = () => new Dec(1).div(STABLE_PAIR_FEE_DIVIDER).toString();
+export const numStringToBytes = (num) => {
+    const bn = new BN(num.toString()).toTwos(256);
+    return bn.toString(16);
+};
+const getPriceFromServer = (fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, network = NetworkNumber.Eth, infoOnly = true) {
+    const fromAssetData = getAssetInfo(fromAsset, network);
+    const toAssetData = getAssetInfo(toAsset, network);
+    const feeDecimal = getFeeDecimal();
+    const excludedSources = ['Balancer_V2', 'Beethovenx'];
+    const allSources = Object.values(OffchainExchanges);
+    try {
+        const res = yield fetch(`${DFS_API_URL}/api/exchange/get-best-price`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                fromAsset: fromAssetData.address,
+                fromAssetDecimals: fromAssetData.decimals,
+                fromAssetSymbol: fromAssetData.symbol,
+                toAsset: toAssetData.address,
+                toAssetDecimals: toAssetData.decimals,
+                toAssetSymbol: toAssetData.symbol,
+                sources: [...allSources.map(s => s.toLowerCase())],
+                chainId: network,
+                amount,
+                excludedSources,
+                infoOnly,
+                takerAddress: userAddress,
+                account: userAddress,
+                noFee: false,
+                feeDecimal,
+                // temporary fix for paraswap until old exchange service is removed
+                shouldFormatParaswapPrice: true,
+            }),
+        });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        const data = (yield res.json());
+        const formattedData = data.map((d, i) => {
+            const source = allSources[i];
+            if (typeof d === 'string')
+                return getOffchainEmptyData(source);
+            return {
+                wrapper: d.wrapper || ZERO_ADDRESS,
+                to: d.to || ZERO_ADDRESS,
+                allowanceTarget: d.allowanceTarget || ZERO_ADDRESS,
+                protocolFee: d.protocolFee || '0',
+                data: d.data || '0x00',
+                value: d.value || '0',
+                gas: d.gas || '0',
+                source: allSources[i],
+                price: d.price,
+                priceWithFee: +(d.price || '0') > 0
+                    ? parseOffchainPrice(fromAssetData.symbol, fromAssetData.decimals, toAssetData.symbol, toAssetData.decimals, d.price, feeDecimal)
+                    : '0',
+            };
+        }).filter((d) => d.wrapper !== ZERO_ADDRESS && d.price !== '0').sort((a, b) => (new Dec(a.price).gt(b.price) ? -1 : 1));
+        return formattedData;
+    }
+    catch (_a) {
+        return allSources.map(source => getOffchainEmptyData(source));
+    }
+});
+export const getBestPrice = (fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, network = NetworkNumber.Eth) {
+    try {
+        const formattedData = yield getPriceFromServer(fromAsset, toAsset, amount, userAddress, network);
+        return formattedData[0] || getOffchainEmptyData();
+    }
+    catch (e) {
+        console.error('Error fetching best price:', e);
+        return getOffchainEmptyData();
+    }
+});
+export const getExchangeOrder = (fromAsset_1, toAsset_1, amount_1, userAddress_1, minPrice_1, ...args_1) => __awaiter(void 0, [fromAsset_1, toAsset_1, amount_1, userAddress_1, minPrice_1, ...args_1], void 0, function* (fromAsset, toAsset, amount, userAddress, minPrice, network = NetworkNumber.Eth) {
+    const fromAssetData = getAssetInfo(fromAsset, network);
+    const toAssetData = getAssetInfo(toAsset, network);
+    const feeDecimal = getFeeDecimal();
+    const offchainQuotes = yield getPriceFromServer(fromAsset, toAsset, amount, userAddress, network, false);
+    const formattedOffchainQuotes = offchainQuotes.map((quote) => ({
+        source: quote.source,
+        price: quote.priceWithFee,
+        wrapper: quote.wrapper,
+        wrapperData: quote.data,
+        offchainData: quote,
+    }));
+    const bestQuote = formattedOffchainQuotes[0];
+    const { offchainData, source, price } = bestQuote;
+    const minPriceFormatted = new Dec(excludeFeeFromPrice(minPrice, fromAssetData.address, toAssetData.address, feeDecimal))
+        .mul(100 - SLIPPAGE_PERCENT)
+        .div(100)
+        .toString();
+    const minPriceForContract = formatPriceWithDecimalForContract(minPriceFormatted, fromAssetData.decimals, toAssetData.decimals);
+    const offchainDataArray = [
+        offchainData.wrapper,
+        offchainData.to,
+        offchainData.allowanceTarget,
+        offchainData.price,
+        offchainData.protocolFee,
+        offchainData.data,
+    ];
+    const value = offchainData.protocolFee;
+    const wrapper = ZERO_ADDRESS;
+    const wrapperData = `0x${numStringToBytes(Math.floor(Date.now() / 1000))}`;
+    const amountWei = assetAmountInWei(amount, fromAsset).toString();
+    if (offchainData.data === '0x00')
+        throw new Error('Offchain data is empty');
+    return {
+        orderData: [
+            fromAssetData.address,
+            toAssetData.address,
+            amountWei,
+            '0',
+            minPriceForContract,
+            STABLE_PAIR_FEE_DIVIDER,
+            '0x0000000000000000000000000000000000000000', // set by contract
+            wrapper,
+            wrapperData,
+            offchainDataArray,
+        ],
+        value,
+        source,
+        price,
+    };
+});

package/esm/execution/index.d.ts

@@ -0,0 +1,2 @@
+import { SupportedMarkets } from '../types';
+export declare const getRequests: (market: SupportedMarkets) => import("../types").Request[];

package/esm/execution/index.js

@@ -0,0 +1,11 @@
+import { SupportedMarkets } from '../types';
+import { getMorphoRequests } from './morpho';
+export const getRequests = (market) => {
+    switch (market) {
+        case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
+            return getMorphoRequests();
+        }
+        default:
+            throw new Error(`Unsupported market: ${market}`);
+    }
+};

package/esm/execution/morpho.d.ts

@@ -0,0 +1,2 @@
+import { Request } from '../types';
+export declare const getMorphoRequests: () => Request[];

package/esm/execution/morpho.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { MorphoManagerContract } from '../contracts';
+import { getViemProvider } from '../services/viem';
+import { RequestType } from '../types';
+import { predictSafeAddress } from '../safe';
+const morphoAuthSignature = {
+    type: RequestType.Signature,
+    getParams: (rpcUrl, network, userAddress) => __awaiter(void 0, void 0, void 0, function* () {
+        const provider = getViemProvider(rpcUrl, network);
+        const managerContract = MorphoManagerContract(provider, network);
+        const nonce = yield managerContract.read.nonce([userAddress]);
+        const tenMinutes = 1000 * 60 * 10;
+        const deadline = Date.now() + tenMinutes;
+        const safeAddress = yield predictSafeAddress(userAddress, rpcUrl, network);
+        return {
+            types: {
+                EIP712Domain: [
+                    { name: 'verifyingContract', type: 'address' },
+                    { name: 'chainId', type: 'uint256' },
+                ],
+                Authorization: [
+                    { name: 'authorizer', type: 'address' },
+                    { name: 'authorized', type: 'address' },
+                    { name: 'isAuthorized', type: 'bool' },
+                    { name: 'nonce', type: 'uint256' },
+                    { name: 'deadline', type: 'uint256' },
+                ],
+            },
+            domain: {
+                chainId: network,
+                verifyingContract: managerContract.address,
+            },
+            primaryType: 'Authorization',
+            message: {
+                authorizer: userAddress,
+                authorized: safeAddress,
+                isAuthorized: true,
+                nonce: +nonce.toString(),
+                deadline,
+            },
+        };
+    }),
+};
+export const getMorphoRequests = () => [morphoAuthSignature];

package/esm/index.d.ts

@@ -1,5 +1,9 @@
 import './setup';
 import * as positionData from './positionData';
 import * as marketData from './marketData';
+import * as exchange from './exchange';
+import * as constants from './constants';
+import * as safe from './safe';
+import * as execution from './execution';
 export * from './types';
-export { positionData, marketData, };
+export { positionData, marketData, exchange, constants, safe, execution, };

package/esm/index.js

@@ -1,5 +1,9 @@
 import './setup';
 import * as positionData from './positionData';
 import * as marketData from './marketData';
+import * as exchange from './exchange';
+import * as constants from './constants';
+import * as safe from './safe';
+import * as execution from './execution';
 export * from './types';
-export { positionData, marketData, };
+export { positionData, marketData, exchange, constants, safe, execution, };

package/esm/positionData/index.d.ts

@@ -1,3 +1,3 @@
 import { MarketData, NetworkNumber, PositionData } from '../types';
 export declare const getMaxLeverageForSupplyAmount: (marketData: MarketData, supplyAmount: string) => number;
-export declare const getResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;
+export declare const getResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/esm/positionData/index.js

@@ -18,10 +18,10 @@ export const getMaxLeverageForSupplyAmount = (marketData, supplyAmount) => {
             throw new Error(`Unsupported market: ${marketData.market}`);
     }
 };
-export const getResultingPosition = (marketData, supplyAmount, leverage, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+export const getResultingPosition = (marketData, supplyAmount, leverage, userAddress, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
     switch (marketData.market) {
         case SupportedMarkets.MorphoBlueSUSDeUSDtb_915: {
-            return getMorphoResultingPosition(marketData, supplyAmount, leverage, rpcUrl, network);
+            return getMorphoResultingPosition(marketData, supplyAmount, leverage, userAddress, rpcUrl, network);
         }
         default:
             throw new Error(`Unsupported market: ${marketData.market}`);

package/esm/positionData/morpho.d.ts

@@ -1,4 +1,4 @@
 import { NetworkNumber } from '@defisaver/positions-sdk';
 import { MarketData, PositionData } from '../types';
 export declare const getMorphoMaxLeverageForSupplyAmount: (marketData: MarketData, supplyAmount: string) => number;
-export declare const getMorphoResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;
+export declare const getMorphoResultingPosition: (marketData: MarketData, supplyAmount: string, leverage: number, userAddress: string, rpcUrl: string, network: NetworkNumber) => Promise<PositionData>;

package/esm/positionData/morpho.js

@@ -8,9 +8,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import Dec from 'decimal.js';
-import { getAssetInfo } from '@defisaver/tokens';
+import { assetAmountInWei, getAssetInfo } from '@defisaver/tokens';
 import { helpers, markets, morphoBlue, MorphoBlueVersions, } from '@defisaver/positions-sdk';
 import { getViemProvider } from '../services/viem';
+import { getBestPrice } from '../exchange';
 const getMaxBoostUsd = (lltv, borrowLimit, debt, targetRatio = 1.01, bufferPercent = 1) => new Dec(targetRatio).mul(debt).sub(borrowLimit)
     .div(new Dec(lltv).sub(targetRatio).toString())
     .mul((100 - bufferPercent) / 100)
@@ -30,19 +31,19 @@ export const getMorphoMaxLeverageForSupplyAmount = (marketData, supplyAmount) =>
     const maxLeverage = new Dec(supplyAmount).plus(new Dec(maxDebt).times(rate)).div(supplyAmount).toNumber();
     return maxLeverage;
 };
-export const getMorphoResultingPosition = (marketData, supplyAmount, leverage, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+export const getMorphoResultingPosition = (marketData, supplyAmount, leverage, userAddress, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
     const provider = getViemProvider(rpcUrl, network);
     const morphoMarket = markets.MorphoBlueMarkets(network)[MorphoBlueVersions.MorphoBlueSUSDeUSDtb_915];
     const { rate: oracle, assetsData, } = marketData;
+    const supplyAsset = Object.values(assetsData).find((asset) => !asset.isDebtAsset);
+    const borrowAsset = Object.values(assetsData).find((asset) => asset.isDebtAsset);
     const debtAmount = new Dec(leverage)
         .times(supplyAmount).minus(supplyAmount).times(oracle)
         .toString();
-    // TODO: add price fetching logic
-    const priceForAmount = new Dec(1).div(oracle).toString();
-    const leveragedAmount = new Dec(debtAmount).times(priceForAmount);
+    const debtAmountWei = assetAmountInWei(debtAmount, borrowAsset.symbol);
+    const { priceWithFee, source } = yield getBestPrice(borrowAsset.symbol, supplyAsset.symbol, debtAmountWei, userAddress, network);
+    const leveragedAmount = new Dec(debtAmount).times(priceWithFee);
     const collIncrease = new Dec(supplyAmount).plus(leveragedAmount).toString();
-    const supplyAsset = Object.values(assetsData).find((asset) => !asset.isDebtAsset);
-    const borrowAsset = Object.values(assetsData).find((asset) => asset.isDebtAsset);
     const morphoMarketData = yield morphoBlue._getMorphoBlueMarketData(provider, network, morphoMarket);
     const usedAssets = {};
     usedAssets[borrowAsset.symbol] = {
@@ -66,5 +67,12 @@ export const getMorphoResultingPosition = (marketData, supplyAmount, leverage, r
         borrowedUsd: '0',
     };
     const aggregatedPosition = helpers.morphoBlueHelpers.getMorphoBlueAggregatedPositionData({ usedAssets, assetsData: morphoMarketData.assetsData, marketInfo: morphoMarketData });
-    return Object.assign({ usedAssets }, aggregatedPosition);
+    return Object.assign({ exchangeInfo: {
+            price: priceWithFee,
+            source,
+            sellAsset: borrowAsset.symbol,
+            sellAmount: debtAmount,
+            buyAsset: supplyAsset.symbol,
+            buyAmount: leveragedAmount.toString(),
+        }, usedAssets }, aggregatedPosition);
 });

package/esm/safe/index.d.ts

@@ -0,0 +1,6 @@
+import { NetworkNumber } from '@defisaver/positions-sdk';
+export declare const getSafeWallets: (userAddress: string, network: NetworkNumber) => Promise<{
+    success: boolean;
+    wallets: string[];
+}>;
+export declare const predictSafeAddress: (owner: string, rpcUrl: string, network: NetworkNumber) => Promise<string>;

package/esm/safe/index.js

@@ -0,0 +1,75 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { encodeFunctionData, encodePacked, getCreate2Address, keccak256, } from 'viem';
+import { SAFE_API_URL, SAFE_REFUND_RECEIVER, SALT_PREFIX, ZERO_ADDRESS, } from '../constants';
+import { getConfigContractAbi, getSafeFactoryAddress, getSafeFallbackHandlerAddress, getSafeWalletSingletonAddress, SafeFactoryContract, } from '../contracts';
+import { getViemProvider } from '../services/viem';
+export const getSafeWallets = (userAddress, network) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield fetch(`${SAFE_API_URL}/safe/all-wallets?network=${network}&account=${userAddress}`);
+        const wallets = yield res.json();
+        const oneOneWallets = wallets
+            .filter((wallet) => wallet.type === 'Safe' && (wallet.owners || []).length === 1)
+            .map((wallet) => wallet.address);
+        return { success: true, wallets: oneOneWallets };
+    }
+    catch (e) {
+        return { success: false, wallets: [] };
+    }
+});
+const getSafeSetupParams = (owners, threshold, network) => [
+    owners,
+    BigInt(threshold),
+    ZERO_ADDRESS,
+    '0x',
+    getSafeFallbackHandlerAddress(network),
+    ZERO_ADDRESS,
+    BigInt(0),
+    SAFE_REFUND_RECEIVER,
+];
+const _predictSafeAddress = (rpcUrl, network, setupArgs, saltNonce) => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = getViemProvider(rpcUrl, network);
+    const safeProxyFactoryAddress = getSafeFactoryAddress(network);
+    const safeProxyFactoryContract = SafeFactoryContract(provider, network);
+    const masterCopyAddress = getSafeWalletSingletonAddress(network);
+    const proxyCreationCode = yield safeProxyFactoryContract.read.proxyCreationCode();
+    // @ts-ignore
+    const initCodeHash = keccak256(encodePacked(['bytes', 'bytes'], [proxyCreationCode, masterCopyAddress.slice(2).padStart(64, '0')]), 'bytes');
+    const salt = keccak256(encodePacked(['bytes', 'uint256'], [keccak256(setupArgs), BigInt(saltNonce)]));
+    return getCreate2Address({
+        bytecodeHash: initCodeHash,
+        from: safeProxyFactoryAddress,
+        salt,
+    });
+});
+export const predictSafeAddress = (owner, rpcUrl, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = getViemProvider(rpcUrl, network);
+    const threshold = 1;
+    const owners = [owner];
+    const setupParams = getSafeSetupParams(owners, threshold, network);
+    const setupParamsEncoded = encodeFunctionData({
+        abi: getConfigContractAbi('Safe130'),
+        functionName: 'setup',
+        // @ts-ignore
+        args: setupParams,
+    });
+    const oneOfOneWalletsCount = (yield getSafeWallets(owner, network)).wallets.length;
+    const failAfter = 10;
+    for (let nonce = oneOfOneWalletsCount + 1; nonce < oneOfOneWalletsCount + failAfter + 1; nonce += 1) {
+        const salt = `${SALT_PREFIX}${nonce}`;
+        const predictedAddr = yield _predictSafeAddress(rpcUrl, network, setupParamsEncoded, salt);
+        const bytecode = yield provider.getCode({ address: predictedAddr });
+        if (!bytecode) {
+            // safe does not exist
+            return predictedAddr;
+        }
+    }
+    return '';
+});