omnipin 3.0.0 → 3.0.1

package/dist/index.js

@@ -9712,7 +9712,7 @@ let createUploadPiecesPayload_metadata = [
 filecoinMainnet.id, filecoinCalibration.id;
 let SIZE_CONSTANTS = {
     TiB: 1n << 40n
-}, LOCKUP_PERIOD = 30n * 2880n, getClientDatasets_abi = {
+}, LOCKUP_PERIOD = 30n * 2880n, DEFAULT_MINIMUM_NEW_DATASET_LOCKUP = 60000000000000000n * LOCKUP_PERIOD / 86400n + 100000000000000000n, getClientDatasets_abi = {
     type: 'function',
     name: 'getClientDataSets',
     inputs: [
@@ -12713,7 +12713,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         }
         attempt < maxAttempts && await promises_setTimeout(intervalMs);
     }
-    throw Error(`Squid bridge poll timed out after ${maxAttempts} attempts for tx ${transactionId}`);
+    throw Error(`Squid bridge poll timed out after ${maxAttempts} attempts; it may still complete — track: https://axelarscan.io/gmp/${transactionId}`);
 }, getRouteWithRetry = async ({ params, attempts = 3, initialDelayMs = 5000, fetchFn = fetch, integratorId = getIntegratorId() })=>{
     let lastErr;
     for(let i = 0; i < attempts; i++)try {
@@ -12731,7 +12731,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         throw e;
     }
     throw lastErr instanceof Error ? lastErr : Error('Squid retry exhausted');
-}, filecoin_bridge_SOURCE_CHAINS = {
+}, FILECOIN_MAINNET_explorer = 'https://filfox.info/en', PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3', MAX_UINT160 = 2n ** 160n - 1n, MAX_UINT48 = 281474976710656 - 1, filecoin_bridge_MAX_UINT256 = 2n ** 256n - 1n, filecoin_bridge_SOURCE_CHAINS = {
     eth: {
         id: 1,
         name: 'Ethereum',
@@ -12867,6 +12867,76 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
             type: 'uint8'
         }
     ]
+}, erc20BalanceOf = {
+    name: 'balanceOf',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+        {
+            name: 'account',
+            type: 'address'
+        }
+    ],
+    outputs: [
+        {
+            type: 'uint256'
+        }
+    ]
+}, permit2Approve = {
+    name: 'approve',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+        {
+            name: 'token',
+            type: 'address'
+        },
+        {
+            name: 'spender',
+            type: 'address'
+        },
+        {
+            name: 'amount',
+            type: 'uint160'
+        },
+        {
+            name: 'expiration',
+            type: 'uint48'
+        }
+    ],
+    outputs: []
+}, permit2Allowance = {
+    name: 'allowance',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+        {
+            name: 'owner',
+            type: 'address'
+        },
+        {
+            name: 'token',
+            type: 'address'
+        },
+        {
+            name: 'spender',
+            type: 'address'
+        }
+    ],
+    outputs: [
+        {
+            name: 'amount',
+            type: 'uint160'
+        },
+        {
+            name: 'expiration',
+            type: 'uint48'
+        },
+        {
+            name: 'nonce',
+            type: 'uint48'
+        }
+    ]
 }, fetchTokenDecimals = async ({ provider, token })=>token.toLowerCase() === NATIVE_TOKEN.toLowerCase() ? 18 : Number(toBigInt(await provider.request({
         method: 'eth_call',
         params: [
@@ -12876,8 +12946,21 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
             },
             'latest'
         ]
-    }))), ensureAllowance = async ({ provider, privateKey, owner, token, spender, amount, chainId })=>{
-    if (toBigInt(await provider.request({
+    }))), fetchSourceBalance = async ({ provider, token, owner })=>token.toLowerCase() === NATIVE_TOKEN.toLowerCase() ? getBalance({
+        provider,
+        address: owner
+    }) : toBigInt(await provider.request({
+        method: 'eth_call',
+        params: [
+            {
+                to: token,
+                data: AbiFunction_encodeData(erc20BalanceOf, [
+                    owner
+                ])
+            },
+            'latest'
+        ]
+    })), readErc20Allowance = async ({ provider, token, owner, spender })=>toBigInt(await provider.request({
         method: 'eth_call',
         params: [
             {
@@ -12889,26 +12972,162 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
             },
             'latest'
         ]
-    })) >= amount) return;
-    logger.info(`Approving ${spender} to spend the source token`);
-    let data = AbiFunction_encodeData(erc20Approve, [
-        spender,
-        2n ** 256n - 1n
-    ]), txHash = await sendTransaction({
+    })), readPermit2Allowance = async ({ provider, token, owner, spender })=>{
+    let raw = await provider.request({
+        method: 'eth_call',
+        params: [
+            {
+                to: PERMIT2_ADDRESS,
+                data: AbiFunction_encodeData(permit2Allowance, [
+                    owner,
+                    token,
+                    spender
+                ])
+            },
+            'latest'
+        ]
+    }), [amount, expiration] = AbiFunction_decodeResult(permit2Allowance, raw);
+    return {
+        amount,
+        expiration
+    };
+}, ensureRouterAllowances = async ({ provider, privateKey, owner, token, spender, amount, chainId })=>{
+    if (await readErc20Allowance({
         provider,
-        chainId,
-        privateKey,
-        to: token,
-        data,
-        from: owner
+        token,
+        owner,
+        spender
+    }) < amount) {
+        logger.info('Approving the router to spend the source token');
+        let txHash = await sendTransaction({
+            provider,
+            chainId,
+            privateKey,
+            to: token,
+            data: AbiFunction_encodeData(erc20Approve, [
+                spender,
+                filecoin_bridge_MAX_UINT256
+            ]),
+            from: owner
+        });
+        await waitForTransaction(provider, txHash);
+    }
+    if (await readErc20Allowance({
+        provider,
+        token,
+        owner,
+        spender: PERMIT2_ADDRESS
+    }) < amount) {
+        logger.info('Approving Permit2 to spend the source token');
+        let txHash = await sendTransaction({
+            provider,
+            chainId,
+            privateKey,
+            to: token,
+            data: AbiFunction_encodeData(erc20Approve, [
+                PERMIT2_ADDRESS,
+                filecoin_bridge_MAX_UINT256
+            ]),
+            from: owner
+        });
+        await waitForTransaction(provider, txHash);
+    }
+    let nowSeconds = Math.floor(Date.now() / 1000), permit2 = await readPermit2Allowance({
+        provider,
+        token,
+        owner,
+        spender
     });
-    await waitForTransaction(provider, txHash);
+    if (permit2.amount < amount || permit2.expiration <= nowSeconds) {
+        logger.info(`Authorizing ${spender} to spend via Permit2`);
+        let txHash = await sendTransaction({
+            provider,
+            chainId,
+            privateKey,
+            to: PERMIT2_ADDRESS,
+            data: AbiFunction_encodeData(permit2Approve, [
+                token,
+                spender,
+                MAX_UINT160,
+                MAX_UINT48
+            ]),
+            from: owner
+        });
+        await waitForTransaction(provider, txHash);
+    }
+}, SOURCE_FINALITY_MS = {
+    eth: 900000
+}, withFinalityCountdown = async ({ chain, label, verbose }, task)=>{
+    let finalityMs = SOURCE_FINALITY_MS[chain];
+    if (!finalityMs || verbose) return task();
+    if (!process.stdout.isTTY) return logger.info(`${label} leg: waiting ~${Math.round(finalityMs / 60000)} min for source-chain finality…`), task();
+    let startedAt = Date.now(), render = ()=>{
+        let totalSeconds, minutes, remaining = finalityMs - (Date.now() - startedAt), line = remaining > 0 ? `⏳ ${label} leg: waiting for finality… ${minutes = Math.floor((totalSeconds = Math.max(0, Math.ceil(remaining / 1000))) / 60), `${minutes}:${(totalSeconds % 60).toString().padStart(2, '0')}`} remaining` : `⏳ ${label} leg: finalized; waiting for relayer… ${Math.round(-remaining / 1000)}s`;
+        process.stdout.cursorTo(0), process.stdout.write(line), process.stdout.clearLine(1);
+    };
+    render();
+    let timer = setInterval(render, 1000);
+    try {
+        return await task();
+    } finally{
+        clearInterval(timer), process.stdout.cursorTo(0), process.stdout.clearLine(0);
+    }
+}, fwssMinimumDeposit = async ()=>{
+    try {
+        let minimumPricePerMonth, epochsPerMonth, pricing = await getServicePricing({
+            chain: filecoinMainnet
+        });
+        return minimumPricePerMonth = pricing.minimumPricePerMonth, epochsPerMonth = pricing.epochsPerMonth, minimumPricePerMonth * LOCKUP_PERIOD / epochsPerMonth + 100000000000000000n;
+    } catch  {
+        return DEFAULT_MINIMUM_NEW_DATASET_LOCKUP;
+    }
+}, applyRatio = (amount, ratio)=>amount * BigInt(Math.round(1000000 * ratio)) / 1000000n, filToUsdfcParams = ({ signer, amount, slippage })=>({
+        fromAddress: signer,
+        fromChain: String(314),
+        fromToken: NATIVE_TOKEN,
+        fromAmount: amount.toString(),
+        toChain: String(314),
+        toToken: '0x80b98d3aa09ffff255c3ba4a241111ff1262f045',
+        toAddress: signer,
+        slippage
+    }), assertClearsFwssFloor = async (route)=>{
+    let floor = await fwssMinimumDeposit(), out = BigInt(route.estimate.toAmountMin ?? route.estimate.toAmount ?? '0');
+    if (out < floor) throw Error(`The USDfc portion would deliver ~${Value_format(out, 18)} USDfc, below Filecoin Pay's minimum deposit of ${Value_format(floor, 18)} USDfc. Bridge a larger amount (or lower --fil-ratio) so the storage portion clears the floor.`);
+}, waitForFilCredit = async ({ provider, address, baseline, maxAttempts = 30, intervalMs = 10000, verbose })=>{
+    for(let i = 0; i < maxAttempts; i++){
+        let balance = await getBalance({
+            provider,
+            address
+        });
+        if (balance > baseline) return balance - baseline;
+        verbose && i % 3 == 0 && logger.info(`Waiting for bridged FIL to land on Filecoin… (poll ${i + 1})`), await promises_setTimeout(intervalMs);
+    }
+    throw Error('Bridged FIL did not appear on Filecoin within the expected window. It may still arrive — check your wallet before retrying.');
+}, estimateFilSwapGas = async ({ provider, signer, route })=>{
+    let tx = route.transactionRequest, gasLimit = tx.gasLimit ? BigInt(tx.gasLimit) : await estimateGas({
+        provider,
+        to: tx.target,
+        data: tx.data,
+        from: signer,
+        value: tx.value ? fromNumber(BigInt(tx.value)) : '0x0'
+    }), block = await provider.request({
+        method: 'eth_getBlockByNumber',
+        params: [
+            'latest',
+            !1
+        ]
+    });
+    return gasLimit * (2n * toBigInt(block?.baseFeePerGas ?? '0x0') + toBigInt(await provider.request({
+        method: 'eth_maxPriorityFeePerGas'
+    }))) * 12n / 10n;
 }, bridgeFilecoin = async ({ privateKey, fromChain, fromToken, amount, to, filRatio, slippage, sourceRpcUrl, verbose })=>{
     let totalAmountAtomic;
     if (filRatio < 0 || filRatio > 1) throw Error(`--fil-ratio must be in [0, 1], got ${filRatio}`);
     let signer = fromPublicKey(Secp256k1_getPublicKey({
         privateKey
-    })), destination = to ?? signer, chainConfig = filecoin_bridge_SOURCE_CHAINS[fromChain], sourceToken = (({ chain, token })=>{
+    }));
+    if ((to ?? signer).toLowerCase() !== signer.toLowerCase()) throw Error('Bridging to Filecoin lands native FIL in your wallet and swaps part of it to USDfc on Filecoin, which must be signed from the receiving wallet. Omit --to (or set it to your own address); bridging to a different address is not supported for this flow.');
+    let chainConfig = filecoin_bridge_SOURCE_CHAINS[fromChain], sourceToken = (({ chain, token })=>{
         if (token.startsWith('0x') && 42 === token.length) return token;
         let upper = token.toUpperCase(), chainConfig = filecoin_bridge_SOURCE_CHAINS[chain];
         for (let [sym, addr] of Object.entries(chainConfig.tokens))if (sym.toUpperCase() === upper) return addr;
@@ -12926,87 +13145,108 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         throw Error(`Invalid amount: ${amount}`);
     }
     if (totalAmountAtomic <= 0n) throw Error(`Amount must be positive: ${amount}`);
-    let filAtomic = totalAmountAtomic * BigInt(Math.round(1000000 * filRatio)) / 1000000n, usdfcAtomic = totalAmountAtomic - filAtomic;
-    logger.start(`Bridge to Filecoin: ${amount} ${fromToken} from ${chainConfig.name} → ${destination}`), logger.info(`Split: ${filAtomic} (FIL leg) + ${usdfcAtomic} (USDfc leg), source-token atomic units`);
-    let filParams = filAtomic > 0n ? {
+    if (logger.start(`Bridge to Filecoin: ${amount} ${fromToken} from ${chainConfig.name}`), await fetchSourceBalance({
+        provider,
+        token: sourceToken,
+        owner: signer
+    }) < totalAmountAtomic) throw Error(`Insufficient ${fromToken} on ${chainConfig.name}`);
+    let bridgeParams = {
         fromAddress: signer,
         fromChain: String(chainConfig.id),
         fromToken: sourceToken,
-        fromAmount: filAtomic.toString(),
+        fromAmount: totalAmountAtomic.toString(),
         toChain: String(314),
         toToken: NATIVE_TOKEN,
-        toAddress: destination,
+        toAddress: signer,
         slippage
-    } : void 0, usdfcParams = usdfcAtomic > 0n ? {
-        fromAddress: signer,
-        fromChain: String(chainConfig.id),
-        fromToken: sourceToken,
-        fromAmount: usdfcAtomic.toString(),
-        toChain: String(314),
-        toToken: '0x80b98d3aa09ffff255c3ba4a241111ff1262f045',
-        toAddress: destination,
-        slippage
-    } : void 0, filRoute = filParams ? await getRouteWithRetry({
-        params: filParams
-    }) : void 0, usdfcRoute = usdfcParams ? await getRouteWithRetry({
-        params: usdfcParams
-    }) : void 0;
-    if (verbose && (filRoute && logRouteSummary('FIL', filRoute), usdfcRoute && logRouteSummary('USDfc', usdfcRoute)), sourceToken.toLowerCase() !== NATIVE_TOKEN.toLowerCase()) {
-        let spender = filRoute?.transactionRequest.target ?? usdfcRoute?.transactionRequest.target;
-        await ensureAllowance({
-            provider,
-            privateKey,
-            owner: signer,
-            token: sourceToken,
-            spender,
-            amount: totalAmountAtomic,
-            chainId: chainConfig.id
-        });
-    }
-    let result = {};
-    if (filRoute && filParams) {
-        logger.info(`Executing FIL leg on ${chainConfig.name}`);
-        let txHash = await executeRoute({
-            provider,
-            privateKey,
-            chainId: chainConfig.id,
+    }, bridgeRoute = await getRouteWithRetry({
+        params: bridgeParams
+    });
+    verbose && logRouteSummary('bridge→FIL', bridgeRoute);
+    let preflightSwapIn = applyRatio(BigInt(bridgeRoute.estimate.toAmountMin ?? bridgeRoute.estimate.toAmount ?? '0'), 1 - filRatio);
+    preflightSwapIn > 0n && await assertClearsFwssFloor(await getRouteWithRetry({
+        params: filToUsdfcParams({
             signer,
-            route: filRoute
-        });
-        logger.info(`FIL leg tx: ${chainConfig.explorer}/tx/${txHash}`), await waitForTransaction(provider, txHash), logger.info('FIL leg source tx confirmed; polling relayer…');
-        let status = await pollSquidStatus({
-            transactionId: txHash,
-            requestId: filRoute.params?.requestId,
+            amount: preflightSwapIn,
+            slippage
+        })
+    })), sourceToken.toLowerCase() !== NATIVE_TOKEN.toLowerCase() && await ensureRouterAllowances({
+        provider,
+        privateKey,
+        owner: signer,
+        token: sourceToken,
+        spender: bridgeRoute.transactionRequest.target,
+        amount: totalAmountAtomic,
+        chainId: chainConfig.id
+    });
+    let result = {}, fil = constants_filProvider[filecoinMainnet.id], filBefore = await getBalance({
+        provider: fil,
+        address: signer
+    });
+    logger.info(`Executing bridge on ${chainConfig.name}`);
+    let bridgeTxHash = await executeRoute({
+        provider,
+        privateKey,
+        chainId: chainConfig.id,
+        signer,
+        route: bridgeRoute
+    });
+    logger.info(`Bridge tx: ${chainConfig.explorer}/tx/${bridgeTxHash}`), await waitForTransaction(provider, bridgeTxHash), logger.info('Bridge source tx confirmed; polling relayer…'), logger.info(`Track: https://axelarscan.io/gmp/${bridgeTxHash}`), result.bridgeStatus = await withFinalityCountdown({
+        chain: fromChain,
+        label: 'bridge',
+        verbose
+    }, ()=>pollSquidStatus({
+            transactionId: bridgeTxHash,
+            requestId: bridgeRoute.params?.requestId,
             fromChainId: String(chainConfig.id),
             toChainId: String(314),
+            maxAttempts: 120,
+            intervalMs: 15000,
             onAttempt: (n, s)=>{
-                verbose && logger.info(`  FIL poll #${n}: status=${s ?? '<none>'}`);
+                verbose && logger.info(`  bridge poll #${n}: status=${s ?? '<none>'}`);
             }
-        });
-        logger.success('FIL leg bridged'), result.filTxHash = txHash, result.filStatus = status;
-    }
-    if (usdfcRoute && usdfcParams) {
-        logger.info(`Executing USDfc leg on ${chainConfig.name}`);
-        let txHash = await executeRoute({
-            provider,
-            privateKey,
-            chainId: chainConfig.id,
+        })), result.bridgeTxHash = bridgeTxHash, logger.success('Bridged to native FIL');
+    let bridgedFil = await waitForFilCredit({
+        provider: fil,
+        address: signer,
+        baseline: filBefore,
+        verbose
+    });
+    result.bridgedFil = Value_format(bridgedFil, 18), logger.info(`Received ${Value_format(bridgedFil, 18)} FIL`);
+    let swapIn = applyRatio(bridgedFil, 1 - filRatio), keptFil = bridgedFil - swapIn;
+    if (swapIn <= 0n) return logger.warn('--fil-ratio leaves nothing to swap; keeping all FIL'), result.keptFil = Value_format(bridgedFil, 18), logger.success('Filecoin bridge complete'), result;
+    let swapRoute = await getRouteWithRetry({
+        params: filToUsdfcParams({
             signer,
-            route: usdfcRoute
-        });
-        logger.info(`USDfc leg tx: ${chainConfig.explorer}/tx/${txHash}`), await waitForTransaction(provider, txHash), logger.info('USDfc leg source tx confirmed; polling relayer…');
-        let status = await pollSquidStatus({
-            transactionId: txHash,
-            requestId: usdfcRoute.params?.requestId,
-            fromChainId: String(chainConfig.id),
-            toChainId: String(314),
-            onAttempt: (n, s)=>{
-                verbose && logger.info(`  USDfc poll #${n}: status=${s ?? '<none>'}`);
-            }
+            amount: swapIn,
+            slippage
+        })
+    }), gasReserve = await estimateFilSwapGas({
+        provider: fil,
+        signer,
+        route: swapRoute
+    });
+    if (keptFil < gasReserve) {
+        if (bridgedFil <= gasReserve) throw Error(`Received FIL (${Value_format(bridgedFil, 18)}) can't cover the on-chain swap gas (~${Value_format(gasReserve, 18)} FIL). Bridge a larger amount.`);
+        swapIn = bridgedFil - gasReserve, keptFil = gasReserve, swapRoute = await getRouteWithRetry({
+            params: filToUsdfcParams({
+                signer,
+                amount: swapIn,
+                slippage
+            })
         });
-        logger.success('USDfc leg bridged'), result.usdfcTxHash = txHash, result.usdfcStatus = status;
     }
-    return logger.success('Filecoin bridge complete'), result;
+    verbose && logRouteSummary('FIL→USDfc', swapRoute);
+    let expectedUsdfc = BigInt(swapRoute.estimate.toAmountMin ?? swapRoute.estimate.toAmount ?? '0'), floor = await fwssMinimumDeposit();
+    expectedUsdfc < floor && logger.warn(`Swap will yield ~${Value_format(expectedUsdfc, 18)} USDfc, below Filecoin Pay's ${Value_format(floor, 18)} USDfc minimum deposit. Proceeding — top up before depositing for storage.`), logger.info(`Swapping ${Value_format(swapIn, 18)} FIL → USDfc on Filecoin (keeping ${Value_format(keptFil, 18)} FIL for gas)`);
+    let swapTxHash = await executeRoute({
+        provider: fil,
+        privateKey,
+        chainId: filecoinMainnet.id,
+        signer,
+        route: swapRoute
+    });
+    return logger.info(`Swap tx: ${FILECOIN_MAINNET_explorer}/tx/${swapTxHash}`), await waitForTransaction(fil, swapTxHash), logger.success('Swapped FIL → USDfc on Filecoin'), result.swapTxHash = swapTxHash, result.keptFil = Value_format(keptFil, 18), result.usdfcExpected = Value_format(expectedUsdfc, 18), logger.success('Filecoin bridge complete'), result;
 }, executeRoute = async ({ provider, privateKey, chainId, signer, route })=>{
     let tx = route.transactionRequest, value = tx.value ? BigInt(tx.value) : 0n;
     return await sendTransaction({
@@ -13100,6 +13340,8 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
     return providers;
 }, findEnvVarProviderName = (provider)=>{
     for (let [token, { name }] of Object.entries(PROVIDERS))if (provider === name) return token;
+    let known = Object.values(PROVIDERS).map((p)=>p.name).join(', ');
+    throw Error(`Unknown provider: '${provider}'. Known providers: ${known}`);
 }, updateDnsLink = async ({ cid, zoneId, apiKey, name, verbose })=>{
     let res = await fetch(`${CLOUDFLARE_API_URL}/zones/${zoneId}/web3/hostnames`, {
         headers: {
@@ -17653,7 +17895,7 @@ let picomatch = __webpack_require__("./node_modules/picomatch/index.js"), isRead
         chainId: filecoinMainnet.id,
         privateKey
     });
-    return logger.info(`Deposit tx: https://filfox.info/en/tx/${depositHash}`), await waitForTransaction(constants_filProvider[filecoinMainnet.id], depositHash), logger.success('Deposit confirmed'), {
+    return logger.info(`Deposit tx: ${FILECOIN_MAINNET_explorer}/tx/${depositHash}`), await waitForTransaction(constants_filProvider[filecoinMainnet.id], depositHash), logger.success('Deposit confirmed'), {
         depositTxHash: depositHash,
         depositedAmount: amountAtomic
     };
@@ -18185,7 +18427,7 @@ cli_cli.command('deploy', ([dir], options)=>deployAction({
         },
         {
             name: 'to',
-            description: 'Destination address on the provider chain. Defaults to the signer address.',
+            description: 'Destination address on the provider chain. Defaults to the signer address. For Filecoin it must be the signer (the destination swap is signed locally).',
             type: 'string'
         },
         {
@@ -18200,7 +18442,7 @@ cli_cli.command('deploy', ([dir], options)=>deployAction({
         },
         {
             name: 'fil-ratio',
-            description: 'Fraction of the input split to FIL (rest to USDfc). Filecoin only. Default 0.1.',
+            description: 'Fraction of the bridged FIL kept for gas; the rest is swapped to USDfc on Filecoin. Filecoin only. Default 0.1.',
             type: 'string'
         },
         {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omnipin",
-	"version": "3.0.0",
+	"version": "3.0.1",
 	"author": "v1rtl <hi@v1rtl.site>",
 	"repository": {
 		"type": "git",