omnipin 2.2.3 → 2.2.4

package/dist/index.js

@@ -10155,7 +10155,9 @@ let filecoinMainnet = {
     [filecoinCalibration.id]: Provider_from(fromHttp('https://api.calibration.node.glif.io/rpc/v1'))
 };
 filecoinMainnet.id, filecoinCalibration.id;
-let getClientDatasets_abi = {
+let SIZE_CONSTANTS = {
+    TiB: 1n << 40n
+}, LOCKUP_PERIOD = 30n * 2880n, getClientDatasets_abi = {
     type: 'function',
     name: 'getClientDataSets',
     inputs: [
@@ -10244,6 +10246,70 @@ let getClientDatasets_abi = {
             'latest'
         ]
     }));
+}, accounts_abi = {
+    type: 'function',
+    inputs: [
+        {
+            name: 'token',
+            internalType: 'contract IERC20',
+            type: 'address'
+        },
+        {
+            name: 'owner',
+            internalType: 'address',
+            type: 'address'
+        }
+    ],
+    name: 'accounts',
+    outputs: [
+        {
+            name: 'funds',
+            internalType: 'uint256',
+            type: 'uint256'
+        },
+        {
+            name: 'lockupCurrent',
+            internalType: 'uint256',
+            type: 'uint256'
+        },
+        {
+            name: 'lockupRate',
+            internalType: 'uint256',
+            type: 'uint256'
+        },
+        {
+            name: 'lockupLastSettledAt',
+            internalType: 'uint256',
+            type: 'uint256'
+        }
+    ],
+    stateMutability: 'view'
+}, accounts_accounts = async (options)=>{
+    let { address, chain } = options, provider = constants_filProvider[chain.id], token = options.token ?? chain.contracts.usdfc.address, [result, currentEpochHex] = await Promise.all([
+        provider.request({
+            method: 'eth_call',
+            params: [
+                {
+                    data: AbiFunction_encodeData(accounts_abi, [
+                        token,
+                        address
+                    ]),
+                    to: chain.contracts.payments.address
+                },
+                'latest'
+            ]
+        }),
+        provider.request({
+            method: 'eth_blockNumber'
+        })
+    ]), [funds, lockupCurrent, lockupRate, lockupLastSettledAt] = AbiFunction_decodeResult(accounts_abi, result), currentEpoch = BigInt(currentEpochHex), actualLockup = lockupCurrent + (currentEpoch > lockupLastSettledAt ? currentEpoch - lockupLastSettledAt : 0n) * lockupRate;
+    return {
+        funds,
+        lockupCurrent,
+        lockupRate,
+        lockupLastSettledAt,
+        availableFunds: funds > actualLockup ? funds - actualLockup : 0n
+    };
 }, exponents = {
     wei: 0,
     gwei: 9,
@@ -10386,7 +10452,49 @@ let getClientDatasets_abi = {
         AbiFunction_decodeResult(erc20Abi[2], results[2]),
         AbiFunction_decodeResult(erc20Abi[3], results[3])
     ];
-}, depositAndApproveOperator_abi = {
+}, signErc20Permit = ({ privateKey, address, amount, nonce, deadline, name, version, chain })=>Secp256k1_sign({
+        privateKey,
+        payload: getSignPayload({
+            domain: {
+                chainId: chain.id,
+                name,
+                version,
+                verifyingContract: chain.contracts.usdfc.address
+            },
+            message: {
+                owner: address,
+                spender: chain.contracts.payments.address,
+                value: amount,
+                nonce,
+                deadline
+            },
+            primaryType: 'Permit',
+            types: {
+                Permit: [
+                    {
+                        name: 'owner',
+                        type: 'address'
+                    },
+                    {
+                        name: 'spender',
+                        type: 'address'
+                    },
+                    {
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        name: 'nonce',
+                        type: 'uint256'
+                    },
+                    {
+                        name: 'deadline',
+                        type: 'uint256'
+                    }
+                ]
+            }
+        })
+    }), deposit_with_permit_abi = {
     type: 'function',
     inputs: [
         {
@@ -10423,80 +10531,18 @@ let getClientDatasets_abi = {
             name: 's',
             internalType: 'bytes32',
             type: 'bytes32'
-        },
-        {
-            name: 'operator',
-            internalType: 'address',
-            type: 'address'
-        },
-        {
-            name: 'rateAllowance',
-            internalType: 'uint256',
-            type: 'uint256'
-        },
-        {
-            name: 'lockupAllowance',
-            internalType: 'uint256',
-            type: 'uint256'
-        },
-        {
-            name: 'maxLockupPeriod',
-            internalType: 'uint256',
-            type: 'uint256'
         }
     ],
-    name: 'depositWithPermitAndApproveOperator',
+    name: 'depositWithPermit',
     outputs: [],
     stateMutability: 'nonpayable'
-}, depositAndApproveOperatorWriteParameters = async ({ privateKey, address, amount, deadline = BigInt(Math.floor(Date.now() / 1000) + 3600), chain })=>{
+}, depositWithPermitWriteParameters = async ({ privateKey, address, amount, deadline = BigInt(Math.floor(Date.now() / 1000) + 3600), chain })=>{
     let [balance, name, nonce, version] = await getErc20WithPermitData({
         address,
         chain
     });
     if (balance < amount) throw Error(`Not enough USDfc to deposit (need: ${Value_format(amount - balance, 18).slice(0, 5)})`);
-    let { r, s, yParity } = await (({ privateKey, address, amount, nonce, deadline, name, version, chain })=>Secp256k1_sign({
-            privateKey,
-            payload: getSignPayload({
-                domain: {
-                    chainId: chain.id,
-                    name,
-                    version,
-                    verifyingContract: chain.contracts.usdfc.address
-                },
-                message: {
-                    owner: address,
-                    spender: chain.contracts.payments.address,
-                    value: amount,
-                    nonce,
-                    deadline
-                },
-                primaryType: 'Permit',
-                types: {
-                    Permit: [
-                        {
-                            name: 'owner',
-                            type: 'address'
-                        },
-                        {
-                            name: 'spender',
-                            type: 'address'
-                        },
-                        {
-                            name: 'value',
-                            type: 'uint256'
-                        },
-                        {
-                            name: 'nonce',
-                            type: 'uint256'
-                        },
-                        {
-                            name: 'deadline',
-                            type: 'uint256'
-                        }
-                    ]
-                }
-            })
-        }))({
+    let { r, s, yParity } = await signErc20Permit({
         privateKey,
         address,
         amount,
@@ -10505,7 +10551,7 @@ let getClientDatasets_abi = {
         nonce,
         version,
         chain
-    }), data = AbiFunction_encodeData(depositAndApproveOperator_abi, [
+    }), data = AbiFunction_encodeData(deposit_with_permit_abi, [
         chain.contracts.usdfc.address,
         address,
         amount,
@@ -10516,20 +10562,16 @@ let getClientDatasets_abi = {
         }),
         fromNumber(s, {
             size: 32
-        }),
-        chain.contracts.storage.address,
-        maxUint256,
-        maxUint256,
-        30n * 2880n
+        })
     ]);
     return {
         provider: constants_filProvider[chain.id],
-        abi: depositAndApproveOperator_abi,
+        abi: deposit_with_permit_abi,
         from: address,
         to: chain.contracts.payments.address,
         data
     };
-}, getAccountInfo_abi = {
+}, deposit_with_permit_and_approve_operator_abi = {
     type: 'function',
     inputs: [
         {
@@ -10538,244 +10580,97 @@ let getClientDatasets_abi = {
             type: 'address'
         },
         {
-            name: 'owner',
+            name: 'to',
             internalType: 'address',
             type: 'address'
-        }
-    ],
-    name: 'accounts',
-    outputs: [
+        },
         {
-            name: 'funds',
+            name: 'amount',
             internalType: 'uint256',
             type: 'uint256'
         },
         {
-            name: 'lockupCurrent',
+            name: 'deadline',
             internalType: 'uint256',
             type: 'uint256'
         },
         {
-            name: 'lockupRate',
+            name: 'v',
+            internalType: 'uint8',
+            type: 'uint8'
+        },
+        {
+            name: 'r',
+            internalType: 'bytes32',
+            type: 'bytes32'
+        },
+        {
+            name: 's',
+            internalType: 'bytes32',
+            type: 'bytes32'
+        },
+        {
+            name: 'operator',
+            internalType: 'address',
+            type: 'address'
+        },
+        {
+            name: 'rateAllowance',
             internalType: 'uint256',
             type: 'uint256'
         },
         {
-            name: 'lockupLastSettledAt',
+            name: 'lockupAllowance',
             internalType: 'uint256',
             type: 'uint256'
-        }
-    ],
-    stateMutability: 'view'
-}, getAccountInfo = async ({ address, chain })=>{
-    let provider = constants_filProvider[chain.id], result = await provider.request({
-        method: 'eth_call',
-        params: [
-            {
-                data: AbiFunction_encodeData(getAccountInfo_abi, [
-                    chain.contracts.usdfc.address,
-                    address
-                ]),
-                to: chain.contracts.payments.address
-            },
-            'latest'
-        ]
-    });
-    return AbiFunction_decodeResult(getAccountInfo_abi, result);
-}, getAvailableFunds = async ({ address, chain })=>{
-    let [funds, lockupCurrent, lockupRate, lockupLastSettledAt] = await getAccountInfo({
-        address,
-        chain
-    }), currentEpoch = BigInt(await constants_filProvider[chain.id].request({
-        method: 'eth_blockNumber'
-    })), epochsSinceSettlement = currentEpoch > lockupLastSettledAt ? currentEpoch - lockupLastSettledAt : 0n, settledLockupCurrent = lockupCurrent + epochsSinceSettlement * lockupRate;
-    return {
-        funds,
-        lockupCurrent,
-        lockupRate,
-        lockupLastSettledAt,
-        currentEpoch,
-        epochsSinceSettlement,
-        settledLockupCurrent,
-        availableFunds: funds > settledLockupCurrent ? funds - settledLockupCurrent : 0n
-    };
-}, DEFAULT_LOCKUP_PERIOD = 30n * 2880n, serviceAbi = [
-    {
-        type: 'function',
-        name: 'getServicePrice',
-        inputs: [],
-        outputs: [
-            {
-                name: 'pricing',
-                internalType: 'struct FilecoinWarmStorageService.ServicePricing',
-                type: 'tuple',
-                components: [
-                    {
-                        name: 'pricePerTiBPerMonthNoCDN',
-                        internalType: 'uint256',
-                        type: 'uint256'
-                    },
-                    {
-                        name: 'pricePerTiBCdnEgress',
-                        internalType: 'uint256',
-                        type: 'uint256'
-                    },
-                    {
-                        name: 'pricePerTiBCacheMissEgress',
-                        internalType: 'uint256',
-                        type: 'uint256'
-                    },
-                    {
-                        name: 'tokenAddress',
-                        internalType: 'contract IERC20',
-                        type: 'address'
-                    },
-                    {
-                        name: 'epochsPerMonth',
-                        internalType: 'uint256',
-                        type: 'uint256'
-                    },
-                    {
-                        name: 'minimumPricePerMonth',
-                        internalType: 'uint256',
-                        type: 'uint256'
-                    }
-                ]
-            }
-        ],
-        stateMutability: 'view'
-    },
-    {
-        type: 'function',
-        name: 'pdpVerifierAddress',
-        inputs: [],
-        outputs: [
-            {
-                name: '',
-                internalType: 'address',
-                type: 'address'
-            }
-        ],
-        stateMutability: 'view'
-    }
-], pdpVerifierAbi = {
-    type: 'function',
-    name: 'USDFC_SYBIL_FEE',
-    inputs: [],
-    outputs: [
+        },
         {
-            name: '',
+            name: 'maxLockupPeriod',
             internalType: 'uint256',
             type: 'uint256'
         }
     ],
-    stateMutability: 'view'
-}, getDataSetCreationRequirements = async ({ chain })=>{
-    let provider = constants_filProvider[chain.id], [servicePriceResult, pdpVerifierResult] = await Promise.all([
-        provider.request({
-            method: 'eth_call',
-            params: [
-                {
-                    to: chain.contracts.storage.address,
-                    data: AbiFunction_encodeData(serviceAbi[0])
-                },
-                'latest'
-            ]
-        }),
-        provider.request({
-            method: 'eth_call',
-            params: [
-                {
-                    to: chain.contracts.storage.address,
-                    data: AbiFunction_encodeData(serviceAbi[1])
-                },
-                'latest'
-            ]
-        })
-    ]), { minimumPricePerMonth } = AbiFunction_decodeResult(serviceAbi[0], servicePriceResult), pdpVerifierAddress = AbiFunction_decodeResult(serviceAbi[1], pdpVerifierResult), verifierAddress = '0x0000000000000000000000000000000000000000' === pdpVerifierAddress ? chain.contracts.pdpVerifier.address : pdpVerifierAddress, sybilFeeResult = await provider.request({
-        method: 'eth_call',
-        params: [
-            {
-                to: verifierAddress,
-                data: AbiFunction_encodeData(pdpVerifierAbi)
-            },
-            'latest'
-        ]
-    }), sybilFee = AbiFunction_decodeResult(pdpVerifierAbi, sybilFeeResult), requirements = (({ minimumPricePerMonth, sybilFee })=>({
-            defaultLockupPeriod: DEFAULT_LOCKUP_PERIOD,
-            epochsPerMonth: DEFAULT_LOCKUP_PERIOD,
-            minimumLockupRequired: minimumPricePerMonth,
-            creationRequirement: minimumPricePerMonth + sybilFee
-        }))({
-        minimumPricePerMonth,
-        sybilFee
+    name: 'depositWithPermitAndApproveOperator',
+    outputs: [],
+    stateMutability: 'nonpayable'
+}, depositWithPermitAndApproveOperatorWriteParameters = async ({ privateKey, address, amount, deadline = BigInt(Math.floor(Date.now() / 1000) + 3600), chain })=>{
+    let [balance, name, nonce, version] = await getErc20WithPermitData({
+        address,
+        chain
     });
+    if (balance < amount) throw Error(`Not enough USDfc to deposit (need: ${Value_format(amount - balance, 18).slice(0, 5)})`);
+    let { r, s, yParity } = await signErc20Permit({
+        privateKey,
+        address,
+        amount,
+        deadline,
+        name,
+        nonce,
+        version,
+        chain
+    }), data = AbiFunction_encodeData(deposit_with_permit_and_approve_operator_abi, [
+        chain.contracts.usdfc.address,
+        address,
+        amount,
+        deadline,
+        void 0 !== yParity ? yParityToV(yParity) : 27,
+        fromNumber(r, {
+            size: 32
+        }),
+        fromNumber(s, {
+            size: 32
+        }),
+        chain.contracts.storage.address,
+        maxUint256,
+        maxUint256,
+        LOCKUP_PERIOD
+    ]);
     return {
-        minimumPricePerMonth,
-        pdpVerifierAddress: verifierAddress,
-        sybilFee,
-        ...requirements
-    };
-}, getServicePrice_abi = {
-    type: 'function',
-    inputs: [],
-    name: 'getServicePrice',
-    outputs: [
-        {
-            name: 'pricing',
-            internalType: 'struct FilecoinWarmStorageService.ServicePricing',
-            type: 'tuple',
-            components: [
-                {
-                    name: 'pricePerTiBPerMonthNoCDN',
-                    internalType: 'uint256',
-                    type: 'uint256'
-                },
-                {
-                    name: 'pricePerTiBCdnEgress',
-                    internalType: 'uint256',
-                    type: 'uint256'
-                },
-                {
-                    name: 'pricePerTiBCacheMissEgress',
-                    internalType: 'uint256',
-                    type: 'uint256'
-                },
-                {
-                    name: 'tokenAddress',
-                    internalType: 'contract IERC20',
-                    type: 'address'
-                },
-                {
-                    name: 'epochsPerMonth',
-                    internalType: 'uint256',
-                    type: 'uint256'
-                },
-                {
-                    name: 'minimumPricePerMonth',
-                    internalType: 'uint256',
-                    type: 'uint256'
-                }
-            ]
-        }
-    ],
-    stateMutability: 'view'
-}, TiB = 1024n ** 4n, getServicePrice = async ({ chain, size: sizeInBytes })=>{
-    let provider = constants_filProvider[chain.id], result = await provider.request({
-        method: 'eth_call',
-        params: [
-            {
-                to: chain.contracts.storage.address,
-                data: AbiFunction_encodeData(getServicePrice_abi)
-            },
-            'latest'
-        ]
-    }), { minimumPricePerMonth, pricePerTiBPerMonthNoCDN, epochsPerMonth } = AbiFunction_decodeResult(getServicePrice_abi, result), linearCost = BigInt(sizeInBytes) * pricePerTiBPerMonthNoCDN / TiB, costWithBuffer = 110n * (linearCost > minimumPricePerMonth ? linearCost : minimumPricePerMonth) / 100n;
-    return {
-        perMonth: costWithBuffer,
-        perEpoch: costWithBuffer / epochsPerMonth,
-        minimumFloor: minimumPricePerMonth,
-        linearCost
+        provider: constants_filProvider[chain.id],
+        abi: deposit_with_permit_and_approve_operator_abi,
+        from: address,
+        to: chain.contracts.payments.address,
+        data
     };
 }, getUSDfcBalance_abi = {
     constant: !0,
@@ -10809,6 +10704,69 @@ let getClientDatasets_abi = {
         ]
     });
     return AbiFunction_decodeResult(getUSDfcBalance_abi, result);
+}, is_fwss_max_approved_abi = {
+    type: 'function',
+    inputs: [
+        {
+            name: 'token',
+            internalType: 'contract IERC20',
+            type: 'address'
+        },
+        {
+            name: 'client',
+            internalType: 'address',
+            type: 'address'
+        },
+        {
+            name: 'operator',
+            internalType: 'address',
+            type: 'address'
+        }
+    ],
+    name: 'operatorApprovals',
+    outputs: [
+        {
+            name: 'isApproved',
+            type: 'bool'
+        },
+        {
+            name: 'rateAllowance',
+            type: 'uint256'
+        },
+        {
+            name: 'lockupAllowance',
+            type: 'uint256'
+        },
+        {
+            name: 'rateUsage',
+            type: 'uint256'
+        },
+        {
+            name: 'lockupUsage',
+            type: 'uint256'
+        },
+        {
+            name: 'maxLockupPeriod',
+            type: 'uint256'
+        }
+    ],
+    stateMutability: 'view'
+}, isFwssMaxApproved = async (options)=>{
+    let { clientAddress, chain } = options, provider = constants_filProvider[chain.id], token = options.token ?? chain.contracts.usdfc.address, result = await provider.request({
+        method: 'eth_call',
+        params: [
+            {
+                data: AbiFunction_encodeData(is_fwss_max_approved_abi, [
+                    token,
+                    clientAddress,
+                    chain.contracts.storage.address
+                ]),
+                to: chain.contracts.payments.address
+            },
+            'latest'
+        ]
+    }), [isApproved, rateAllowance, lockupAllowance] = AbiFunction_decodeResult(is_fwss_max_approved_abi, result);
+    return isApproved && rateAllowance === maxUint256 && lockupAllowance === maxUint256;
 }, uploadPiece = async ({ providerURL, pieceCid, bytes })=>{
     let res = await fetch(new URL('/pdp/piece', providerURL), {
         method: 'POST',
@@ -11825,7 +11783,182 @@ class cid_CID {
         return cid_baseCache(cid).set(prefix, source), cid;
     }
 }
-let DAG_PB_CODE = 0x70, SHA_256_CODE = 0x12, cidSymbol = Symbol.for('@ipld/js-cid/CID'), link_DAG_PB_CODE = 0x70, varint_0 = __webpack_require__("./node_modules/varint/index.js"), calculatePieceCID_FR_RATIO = 254 / 256, MIN_PAYLOAD_SIZE = 127, fromRpcStatus = {
+let DAG_PB_CODE = 0x70, SHA_256_CODE = 0x12, cidSymbol = Symbol.for('@ipld/js-cid/CID'), link_DAG_PB_CODE = 0x70, varint_0 = __webpack_require__("./node_modules/varint/index.js"), calculatePieceCID_FR_RATIO = 254 / 256, MIN_PAYLOAD_SIZE = 127, calculateEffectiveRate = (params)=>{
+    let { sizeInBytes, pricePerTiBPerMonth, minimumPricePerMonth, epochsPerMonth } = params, naturalPerMonth = pricePerTiBPerMonth * sizeInBytes / SIZE_CONSTANTS.TiB, naturalPerEpoch = pricePerTiBPerMonth * sizeInBytes / (SIZE_CONSTANTS.TiB * epochsPerMonth), minimumPerEpoch = minimumPricePerMonth / epochsPerMonth;
+    return {
+        ratePerEpoch: naturalPerEpoch > minimumPerEpoch ? naturalPerEpoch : minimumPerEpoch,
+        ratePerMonth: naturalPerMonth > minimumPricePerMonth ? naturalPerMonth : minimumPricePerMonth
+    };
+}, get_service_pricing_abi = {
+    type: 'function',
+    inputs: [],
+    name: 'getServicePrice',
+    outputs: [
+        {
+            name: 'pricing',
+            internalType: 'struct FilecoinWarmStorageService.ServicePricing',
+            type: 'tuple',
+            components: [
+                {
+                    name: 'pricePerTiBPerMonthNoCDN',
+                    internalType: 'uint256',
+                    type: 'uint256'
+                },
+                {
+                    name: 'pricePerTiBCdnEgress',
+                    internalType: 'uint256',
+                    type: 'uint256'
+                },
+                {
+                    name: 'pricePerTiBCacheMissEgress',
+                    internalType: 'uint256',
+                    type: 'uint256'
+                },
+                {
+                    name: 'tokenAddress',
+                    internalType: 'contract IERC20',
+                    type: 'address'
+                },
+                {
+                    name: 'epochsPerMonth',
+                    internalType: 'uint256',
+                    type: 'uint256'
+                },
+                {
+                    name: 'minimumPricePerMonth',
+                    internalType: 'uint256',
+                    type: 'uint256'
+                }
+            ]
+        }
+    ],
+    stateMutability: 'view'
+}, getServicePricing = async ({ chain })=>{
+    let provider = constants_filProvider[chain.id], result = await provider.request({
+        method: 'eth_call',
+        params: [
+            {
+                to: chain.contracts.storage.address,
+                data: AbiFunction_encodeData(get_service_pricing_abi)
+            },
+            'latest'
+        ]
+    });
+    return AbiFunction_decodeResult(get_service_pricing_abi, result);
+}, getUploadCosts = async (options)=>{
+    var params;
+    let lockup, netRateAfterUpload, extraRunwayEpochs, bufferEpochs, runway, rawDepositNeeded, buffer, isNewDataSet = options.isNewDataSet ?? !0, currentDataSetSize = options.currentDataSetSize ?? 0n, extraRunwayEpochs1 = options.extraRunwayEpochs ?? 0n, bufferEpochs1 = options.bufferEpochs ?? 5n, provider = constants_filProvider[options.chain.id], [accountInfo, pricing, approved, currentEpochHex] = await Promise.all([
+        accounts_accounts({
+            address: options.clientAddress,
+            chain: options.chain
+        }),
+        getServicePricing({
+            chain: options.chain
+        }),
+        isFwssMaxApproved({
+            clientAddress: options.clientAddress,
+            chain: options.chain
+        }),
+        provider.request({
+            method: 'eth_blockNumber'
+        })
+    ]), currentEpoch = BigInt(currentEpochHex), rate = calculateEffectiveRate({
+        sizeInBytes: currentDataSetSize + options.dataSize,
+        pricePerTiBPerMonth: pricing.pricePerTiBPerMonthNoCDN,
+        minimumPricePerMonth: pricing.minimumPricePerMonth,
+        epochsPerMonth: pricing.epochsPerMonth
+    }), accountParams = {
+        funds: accountInfo.funds,
+        lockupCurrent: accountInfo.lockupCurrent,
+        lockupRate: accountInfo.lockupRate,
+        lockupLastSettledAt: accountInfo.lockupLastSettledAt,
+        currentEpoch
+    }, debt = ((params)=>{
+        let { funds, lockupCurrent, lockupRate, lockupLastSettledAt, currentEpoch } = params, totalOwed = lockupCurrent + lockupRate * (currentEpoch > lockupLastSettledAt ? currentEpoch - lockupLastSettledAt : 0n);
+        return totalOwed > funds ? totalOwed - funds : 0n;
+    })(accountParams), { availableFunds, fundedUntilEpoch } = ((params)=>{
+        let { funds, lockupCurrent, lockupRate, lockupLastSettledAt, currentEpoch } = params, fundedUntilEpoch = 0n === lockupRate ? 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn : lockupLastSettledAt + (funds - lockupCurrent) / lockupRate, simulatedSettledAt = fundedUntilEpoch < currentEpoch ? fundedUntilEpoch : currentEpoch, simulatedLockupCurrent = lockupCurrent + lockupRate * (simulatedSettledAt > lockupLastSettledAt ? simulatedSettledAt - lockupLastSettledAt : 0n);
+        return {
+            fundedUntilEpoch,
+            availableFunds: funds > simulatedLockupCurrent ? funds - simulatedLockupCurrent : 0n
+        };
+    })(accountParams), depositNeeded = (lockup = ((params)=>{
+        let rateDeltaPerEpoch, { dataSize, currentDataSetSize, pricePerTiBPerMonth, minimumPricePerMonth, epochsPerMonth = 86400n, lockupEpochs = LOCKUP_PERIOD, isNewDataSet } = params, rateParams = {
+            pricePerTiBPerMonth,
+            minimumPricePerMonth,
+            epochsPerMonth
+        };
+        if (currentDataSetSize > 0n && !isNewDataSet) {
+            let newRate = calculateEffectiveRate({
+                ...rateParams,
+                sizeInBytes: currentDataSetSize + dataSize
+            }), currentRate = calculateEffectiveRate({
+                ...rateParams,
+                sizeInBytes: currentDataSetSize
+            });
+            (rateDeltaPerEpoch = newRate.ratePerEpoch - currentRate.ratePerEpoch) < 0n && (rateDeltaPerEpoch = 0n);
+        } else rateDeltaPerEpoch = calculateEffectiveRate({
+            ...rateParams,
+            sizeInBytes: dataSize
+        }).ratePerEpoch;
+        let rateLockupDelta = rateDeltaPerEpoch * lockupEpochs, sybilFee = isNewDataSet ? 100000000000000000n : 0n;
+        return {
+            rateDeltaPerEpoch,
+            rateLockupDelta,
+            sybilFee,
+            total: rateLockupDelta + sybilFee
+        };
+    })({
+        dataSize: (params = {
+            dataSize: options.dataSize,
+            currentDataSetSize,
+            pricePerTiBPerMonth: pricing.pricePerTiBPerMonthNoCDN,
+            minimumPricePerMonth: pricing.minimumPricePerMonth,
+            epochsPerMonth: pricing.epochsPerMonth,
+            lockupEpochs: LOCKUP_PERIOD,
+            isNewDataSet,
+            currentLockupRate: accountInfo.lockupRate,
+            extraRunwayEpochs: extraRunwayEpochs1,
+            debt,
+            availableFunds,
+            fundedUntilEpoch,
+            currentEpoch,
+            bufferEpochs: bufferEpochs1
+        }).dataSize,
+        currentDataSetSize: params.currentDataSetSize,
+        pricePerTiBPerMonth: params.pricePerTiBPerMonth,
+        minimumPricePerMonth: params.minimumPricePerMonth,
+        epochsPerMonth: params.epochsPerMonth,
+        lockupEpochs: params.lockupEpochs,
+        isNewDataSet: params.isNewDataSet
+    }), netRateAfterUpload = params.currentLockupRate + lockup.rateDeltaPerEpoch, extraRunwayEpochs = params.extraRunwayEpochs ?? 0n, bufferEpochs = params.bufferEpochs ?? 5n, runway = (({ netRateAfterUpload, extraRunwayEpochs })=>netRateAfterUpload * extraRunwayEpochs)({
+        netRateAfterUpload,
+        extraRunwayEpochs
+    }), rawDepositNeeded = lockup.total + runway + params.debt - params.availableFunds, buffer = 0n === params.currentLockupRate && params.isNewDataSet ? 0n : (({ rawDepositNeeded, netRateAfterUpload, fundedUntilEpoch, currentEpoch, availableFunds, bufferEpochs })=>{
+        if (rawDepositNeeded > 0n) return netRateAfterUpload * bufferEpochs;
+        if (fundedUntilEpoch <= currentEpoch + bufferEpochs) {
+            let needed = netRateAfterUpload * bufferEpochs - availableFunds;
+            return needed > 0n ? needed : 0n;
+        }
+        return 0n;
+    })({
+        rawDepositNeeded,
+        netRateAfterUpload,
+        fundedUntilEpoch: params.fundedUntilEpoch,
+        currentEpoch: params.currentEpoch,
+        availableFunds: params.availableFunds,
+        bufferEpochs
+    }), (rawDepositNeeded > 0n ? rawDepositNeeded : 0n) + buffer), needsFwssMaxApproval = !approved;
+    return {
+        rate: {
+            perEpoch: rate.ratePerEpoch,
+            perMonth: rate.ratePerMonth
+        },
+        depositNeeded,
+        needsFwssMaxApproval,
+        ready: 0n === depositNeeded && !needsFwssMaxApproval
+    };
+}, fromRpcStatus = {
     '0x0': 'reverted',
     '0x1': 'success'
 }, fromRpcType = {
@@ -12129,11 +12262,6 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         chain
     });
     verbose && logger.info(`Filecoin SP Payee: ${payee}`);
-    let { perMonth } = await getServicePrice({
-        size,
-        chain
-    });
-    logger.info(`Price for storage: ${Value_format(perMonth, 18)} USDfc/month`);
     let pieceCid = link_create(raw_code, digest_create(0x1011, function(data) {
         let fr32 = function(source) {
             let output = new Uint8Array(Math.floor(toZeroPaddedSize(source.length) / calculatePieceCID_FR_RATIO)), quadCount = toZeroPaddedSize(source.length) / 127;
@@ -12193,22 +12321,23 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
     }(bytes))), providerActiveDataSets = (await getClientDataSets({
         chain,
         address
-    })).filter((ds)=>ds.providerId === providerId && 0n === ds.pdpEndEpoch), isNewDataSet = 0 === providerActiveDataSets.length || filecoinForceNewDataset, creationRequirement = isNewDataSet ? (await getDataSetCreationRequirements({
-        chain
-    })).creationRequirement : 0n, requiredAmount = isNewDataSet && creationRequirement > perMonth ? creationRequirement : perMonth;
-    verbose && (logger.info(`Storage price: ${Value_format(perMonth, 18)} USDFC/month`), isNewDataSet && logger.info(`Creation requirement: ${Value_format(creationRequirement, 18)} USDFC`), logger.info(`Required funds: ${Value_format(requiredAmount, 18)} USDFC`));
-    let { funds, availableFunds } = await getAvailableFunds({
-        address,
+    })).filter((ds)=>ds.providerId === providerId && 0n === ds.pdpEndEpoch), isNewDataSet = 0 === providerActiveDataSets.length || filecoinForceNewDataset, costs = await getUploadCosts({
+        clientAddress: address,
+        dataSize: BigInt(size),
+        isNewDataSet,
         chain
     });
-    verbose && logger.info(`Filecoin Pay deposited funds: ${Value_format(funds, 18)} USDFC`), logger.info(`Filecoin Pay available funds: ${Value_format(availableFunds, 18)} USDFC`);
-    let depositNeeded = requiredAmount > availableFunds ? requiredAmount - availableFunds : 0n;
-    if (depositNeeded > 0n) {
-        verbose && logger.info(`Depositing ${Value_format(depositNeeded, 18)} USDFC`);
-        let params = await depositAndApproveOperatorWriteParameters({
+    if (logger.info(`Price for storage: ${Value_format(costs.rate.perMonth, 18)} USDfc/month`), verbose && (logger.info(`Storage price: ${Value_format(costs.rate.perMonth, 18)} USDFC/month`), logger.info(`Required deposit: ${Value_format(costs.depositNeeded, 18)} USDFC`), logger.info(`FWSS max-approved: ${costs.needsFwssMaxApproval ? 'no' : 'yes'}`)), costs.depositNeeded > 0n) {
+        verbose && logger.info(`Depositing ${Value_format(costs.depositNeeded, 18)} USDFC`);
+        let params = costs.needsFwssMaxApproval ? await depositWithPermitAndApproveOperatorWriteParameters({
+            privateKey,
+            address,
+            amount: costs.depositNeeded,
+            chain
+        }) : await depositWithPermitWriteParameters({
             privateKey,
             address,
-            amount: depositNeeded,
+            amount: costs.depositNeeded,
             chain
         });
         await simulateTransaction(params);
@@ -12218,7 +12347,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
             privateKey
         });
         verbose && logger.info(`Deposit transaction: ${hash}`), await waitForTransaction(constants_filProvider[chain.id], hash), logger.success('Deposit confirmed');
-    } else logger.info('Sufficient funds available, no deposit needed');
+    } else costs.needsFwssMaxApproval ? logger.info('Operator approval needed but no deposit; skipping (no-op).') : logger.info('Sufficient funds available, no deposit needed');
     let nonce = BigInt(randomInt(100000000));
     if (isNewDataSet) {
         logger.info('Creating new data set'), verbose && logger.info('Uploading piece to provider'), await uploadPiece({
@@ -17848,7 +17977,7 @@ let uploadCAR = async (conf, car)=>{
     return multihash = digest_create(0x1b, function(hex, options = {}) {
         return fromHex(hex, options);
     }(ref)).bytes, bytes = new Uint8Array((hashOffset = (codeOffset = varint_0.encodingLength(1)) + varint_0.encodingLength(0xfa)) + multihash.byteLength), varint_0.encode(1, bytes, 0), varint_0.encode(0xfa, bytes, codeOffset), bytes.set(multihash, hashOffset), bytes;
-}, swarmy_providerName = 'Swarmy', PROVIDERS = {
+}, referenceToCIDString = (ref)=>base32.encode(referenceToCID(ref)), swarmy_providerName = 'Swarmy', PROVIDERS = {
     STORACHA_TOKEN: {
         name: 'Storacha',
         upload: async ({ token, bytes, proof })=>{
@@ -17950,7 +18079,7 @@ let uploadCAR = async (conf, car)=>{
             }), json = await res.json();
             if (verbose && logger.request('POST', res.url, res.status), !res.ok) throw new DeployError(swarmy_providerName, json.message);
             return {
-                cid: referenceToCID(`0x${json.swarmReference}`).toString(),
+                cid: referenceToCIDString(`0x${json.swarmReference}`),
                 rID: json.swarmReference
             };
         },
@@ -17976,7 +18105,7 @@ let uploadCAR = async (conf, car)=>{
             }), json = await res.json();
             if (verbose && logger.request('POST', res.url, res.status), !res.ok) throw new DeployError('Bee', json.message);
             return {
-                cid: referenceToCID(`0x${json.reference}`).toString(),
+                cid: referenceToCIDString(`0x${json.reference}`),
                 rID: json.reference
             };
         },
@@ -21329,7 +21458,7 @@ let ENS_DEPLOYER_ROLE = keccak256(Bytes_fromString('ENS_DEPLOYER')), execTransac
         let browserLink = `https://${domain}.limo`;
         logger.info(`Open in a browser: ${isTTY ? styleText('underline', browserLink) : browserLink}`);
     }
-}, packTAR = async (files)=>{
+}, tar_tmp = tmpdir(), packTAR = async (files, name, dir = tar_tmp)=>{
     let entries = [];
     for (let { path, content } of files){
         let chunks = [], totalLength = 0;
@@ -21341,7 +21470,7 @@ let ENS_DEPLOYER_ROLE = keccak256(Bytes_fromString('ENS_DEPLOYER')), execTransac
             data: fileData
         });
     }
-    return function(files, opts = {}) {
+    let bytes = function(files, opts = {}) {
         let _files = files.map((file)=>{
             let data = function(data) {
                 if (null != data) return "string" == typeof data ? new TextEncoder().encode(data) : data instanceof ArrayBuffer ? new Uint8Array(data) : data;
@@ -21373,6 +21502,15 @@ let ENS_DEPLOYER_ROLE = keccak256(Bytes_fromString('ENS_DEPLOYER')), execTransac
         }
         return new Uint8Array(buffer);
     }(entries);
+    if (!name) return {
+        bytes,
+        output: null
+    };
+    let output = `${dir}/${name}.tar`;
+    return await writeFile(output, bytes), {
+        bytes,
+        output
+    };
 }, packAction = async ({ dir, options = {} })=>{
     let { name: customName, dist, verbose, 'only-hash': onlyHash, tar } = options;
     dir || (dir = await exists('dist') ? 'dist' : await exists('.vitepress/dist') ? '.vitepress/dist' : '.');
@@ -21382,20 +21520,23 @@ let ENS_DEPLOYER_ROLE = keccak256(Bytes_fromString('ENS_DEPLOYER')), execTransac
         '.',
         'dist'
     ].includes(dir) ? name : dir;
-    if (onlyHash || logger.start(`Packing ${isTTY ? styleText('cyan', distName) : distName} (${fileSize(size, 2)})`), tar) return {
-        bytes: await packTAR(files),
-        size
-    };
-    {
-        let { rootCID, bytes } = await packCAR(files, name, dist), cid = rootCID.toString();
-        return onlyHash ? console.log(cid) : logger.info(`Root CID: ${isTTY ? styleText('white', cid) : cid}`), {
+    if (onlyHash || logger.start(`Packing ${isTTY ? styleText('cyan', distName) : distName} (${fileSize(size, 2)})`), tar) {
+        let { bytes, output } = await packTAR(files, name, dist);
+        return !onlyHash && output && logger.info(`TAR: ${isTTY ? styleText('white', output) : output}`), {
             name,
-            cid,
             bytes,
             files,
             size
         };
     }
+    let { rootCID, bytes } = await packCAR(files, name, dist), cid = rootCID.toString();
+    return onlyHash ? console.log(cid) : logger.info(`Root CID: ${isTTY ? styleText('white', cid) : cid}`), {
+        name,
+        cid,
+        bytes,
+        files,
+        size
+    };
 }, deployAction = async ({ dir, options = {} })=>{
     let cid, { strict, ens, chain = 'mainnet', name: customName, dist, verbose = !1, providers: providersList, dnslink, 'progress-bar': progressBar, 'filecoin-chain': filecoinChain, 'filecoin-force-new-dataset': filecoinForceNewDataset, ...opts } = options, apiTokens = parseTokensFromEnv(), allProviders = (providersList ? providersList.split(',') : tokensToProviderNames(apiTokens.keys())).map((providerName)=>PROVIDERS[findEnvVarProviderName(providerName)]), ipfsProviders = allProviders.filter((p)=>'ipfs' === p.protocol), swarmProviders = allProviders.filter((p)=>'swarm' === p.protocol);
     if (ipfsProviders.sort((a)=>'both' === a.supported || 'upload' === a.supported ? -1 : 1), !allProviders.length) throw new NoProvidersError();
@@ -21940,9 +22081,15 @@ cli_cli.command('deploy', ([dir], options)=>deployAction({
             description: 'More verbose logs',
             type: 'boolean',
             short: 'v'
+        },
+        {
+            name: 'tar',
+            description: 'Pack as a TAR archive (for Swarm) instead of a CAR',
+            type: 'boolean',
+            short: 't'
         }
     ],
-    description: 'Pack websites files into a CAR without uploading it anywhere'
+    description: 'Pack websites files into a CAR (or TAR with --tar) without uploading it anywhere'
 }), cli_cli.command('pin', ([cid], options)=>pinAction({
         cid,
         options

package/package.json

@@ -1,79 +1,81 @@
 {
-  "name": "omnipin",
-  "version": "2.2.3",
-  "author": "v1rtl <hi@v1rtl.site>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/omnipin/omnipin.git"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^2.4.7",
-    "@ipld/car": "^5.4.2",
-    "@ipld/dag-ucan": "^3.4.5",
-    "@omnipin/foc": "npm:@jsr/omnipin__foc@0.0.12",
-    "@rslib/core": "^0.20.0",
-    "@size-limit/file": "^12.0.1",
-    "@stauro/filebase-upload": "npm:@jsr/stauro__filebase-upload",
-    "@storacha/capabilities": "^2.3.0",
-    "@types/bun": "^1.3.10",
-    "@types/varint": "^6.0.3",
-    "@ucanto/client": "^9.0.2",
-    "@ucanto/core": "^10.4.6",
-    "@ucanto/principal": "^9.0.3",
-    "@ucanto/transport": "^9.2.1",
-    "@web3-storage/data-segment": "^5.3.0",
-    "cborg": "^4.5.8",
-    "ipfs-unixfs-importer": "^16.1.4",
-    "multiformats": "13.4.2",
-    "nanotar": "^0.3.0",
-    "ox": "^0.14.8",
-    "size-limit": "^12.0.1",
-    "spektr": "^0.2.0",
-    "tinyglobby": "^0.2.15",
-    "typescript": "^5.9.3",
-    "varint": "^6.0.0",
-    "vitepress": "^1.6.4"
-  },
-  "bin": {
-    "omnipin": "dist/index.js"
-  },
-  "description": "🌸 Self-custodial decentralized deployments",
-  "engineStrict": true,
-  "engines": {
-    "node": "^20.10.0 || >=21.1.0"
-  },
-  "files": [
-    "dist"
-  ],
-  "homepage": "https://github.com/omnipin/omnipin",
-  "keywords": [
-    "ipfs",
-    "filecoin",
-    "deploy",
-    "cli"
-  ],
-  "license": "MIT",
-  "overrides": {
-    "multiformats": "13.4.2"
-  },
-  "release": {
-    "branches": [
-      "main"
-    ]
-  },
-  "scripts": {
-    "build": "rslib",
-    "prepublishOnly": "bun run build && bun size-limit",
-    "check": "biome check",
-    "types": "tsc --noEmit",
-    "test:report": "bun test --coverage --coverage-reporter=lcov --coverage-dir=coverage"
-  },
-  "size-limit": [
-    {
-      "path": "dist/index.js",
-      "limit": "1MB",
-      "brotli": false
-    }
-  ],
-  "type": "module"
+	"name": "omnipin",
+	"version": "2.2.4",
+	"author": "v1rtl <hi@v1rtl.site>",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/omnipin/omnipin.git"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.4.7",
+		"@ipld/car": "^5.4.2",
+		"@ipld/dag-ucan": "^3.4.5",
+		"@omnipin/foc": "npm:@jsr/omnipin__foc@0.0.14",
+		"@rslib/core": "^0.20.0",
+		"@size-limit/file": "^12.0.1",
+		"@stauro/filebase-upload": "npm:@jsr/stauro__filebase-upload",
+		"@storacha/capabilities": "^2.3.0",
+		"@types/bun": "^1.3.10",
+		"@types/varint": "^6.0.3",
+		"@ucanto/client": "^9.0.2",
+		"@ucanto/core": "^10.4.6",
+		"@ucanto/principal": "^9.0.3",
+		"@ucanto/transport": "^9.2.1",
+		"@web3-storage/data-segment": "^5.3.0",
+		"cborg": "^4.5.8",
+		"ipfs-unixfs-importer": "^16.1.4",
+		"multiformats": "13.4.2",
+		"nanotar": "^0.3.0",
+		"ox": "^0.14.8",
+		"prool": "^0.2.4",
+		"size-limit": "^12.0.1",
+		"spektr": "^0.2.0",
+		"tinyglobby": "^0.2.15",
+		"typescript": "^5.9.3",
+		"varint": "^6.0.0",
+		"vitepress": "^1.6.4"
+	},
+	"bin": {
+		"omnipin": "dist/index.js"
+	},
+	"description": "🌸 Self-custodial decentralized deployments",
+	"engineStrict": true,
+	"engines": {
+		"node": "^20.10.0 || >=21.1.0"
+	},
+	"files": [
+		"dist"
+	],
+	"homepage": "https://github.com/omnipin/omnipin",
+	"keywords": [
+		"ipfs",
+		"filecoin",
+		"deploy",
+		"cli"
+	],
+	"license": "MIT",
+	"overrides": {
+		"multiformats": "13.4.2"
+	},
+	"release": {
+		"branches": [
+			"main"
+		]
+	},
+	"scripts": {
+		"build": "rslib",
+		"prepublishOnly": "bun run build && bun size-limit",
+		"check": "biome check",
+		"types": "tsc --noEmit",
+		"test:report": "bun test test/ --coverage --coverage-reporter=lcov --coverage-dir=coverage",
+		"test:e2e": "bun test e2e/"
+	},
+	"size-limit": [
+		{
+			"path": "dist/index.js",
+			"limit": "1MB",
+			"brotli": false
+		}
+	],
+	"type": "module"
 }