{"version":3,"sources":["../../src/generated/operations.generated.ts"],"sourcesContent":["// AUTO-GENERATED from manifest.json — do not edit by hand.\n// Regenerate with: yarn workspace @lifi/composer-sdk generate\n\nimport type {\n AnyBindable,\n FlowBuilderInternal,\n} from '../authoring/FlowBuilderCore.js';\nimport type { Bindable, OutputHandle } from '../authoring/handles.js';\nimport type {\n CoreCallResult,\n SignatureBind,\n StaticCallResult,\n} from '../authoring/signatureArgs.js';\nimport {\n buildCallWireFormat,\n buildStaticCallWireFormat,\n} from '../authoring/signatureArgs.js';\nimport type { TypedGuard } from '../types.js';\n\nimport type {\n AaveBorrowConfig,\n AaveClaimRewardsConfig,\n AaveRepayConfig,\n AaveRepayWithATokensConfig,\n AaveSetEModeConfig,\n CoreApproveConfig,\n CoreAsResourceConfig,\n CoreBalanceOfConfig,\n CoreBpsDownConfig,\n CoreBpsUpConfig,\n CoreCallConfig,\n CoreEmitEvent1Config,\n CoreEmitEvent2Config,\n CoreEmitEvent3Config,\n CoreEmitEvent4Config,\n CorePeekConfig,\n CoreRawCallConfig,\n CoreSplitConfig,\n CoreStaticCallConfig,\n CoreTransferConfig,\n InvariantNumericConfig,\n InvariantNumericInRangeConfig,\n LifiSwapConfig,\n LifiZapConfig,\n MorphoBlueSupplyCollateralConfig,\n MorphoBlueWithdrawCollateralConfig,\n ParaswapBuyConfig,\n} from './config.generated.js';\n\n/** Split a resource into two outputs by basis-point ratio */\nexport interface CoreSplitArgs {\n readonly bind: {\n readonly source: Bindable<'resource'>;\n };\n readonly config: CoreSplitConfig;\n readonly guards?: readonly TypedGuard<'a' | 'b'>[];\n}\n\n/** Merge two same-token resources into one by addition */\nexport interface CoreMergeArgs {\n readonly bind: {\n readonly a: Bindable<'resource'>;\n readonly b: Bindable<'resource'>;\n };\n readonly guards?: readonly TypedGuard<'merged'>[];\n}\n\n/** Swap tokens via the LI.FI aggregator API */\nexport interface LifiSwapArgs {\n readonly bind: {\n readonly amountIn: Bindable<'resource'>;\n };\n readonly config: LifiSwapConfig;\n readonly guards?: readonly TypedGuard<'unspentIn'>[];\n}\n\n/** Assert that an account holds at least a minimum token balance */\nexport interface InvariantBalanceAtLeastArgs {\n readonly bind: {\n readonly minimumAmount: Bindable<'resource'>;\n readonly account: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert that an account holds exactly an expected token balance */\nexport interface InvariantBalanceEqualsArgs {\n readonly bind: {\n readonly expectedAmount: Bindable<'resource'>;\n readonly account: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert that an account holds at most a maximum token balance */\nexport interface InvariantBalanceAtMostArgs {\n readonly bind: {\n readonly maximumAmount: Bindable<'resource'>;\n readonly account: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert that an account's token balance is between a minimum and a maximum (inclusive) */\nexport interface InvariantBalanceInRangeArgs {\n readonly bind: {\n readonly minimumAmount: Bindable<'resource'>;\n readonly maximumAmount: Bindable<'uint256'>;\n readonly account: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert that a spender is permitted to move at least a minimum allowance on behalf of an owner */\nexport interface InvariantAllowanceAtLeastArgs {\n readonly bind: {\n readonly minimumAmount: Bindable<'resource'>;\n readonly owner: Bindable<'address'>;\n readonly spender: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert that a spender's allowance on behalf of an owner exactly equals an expected amount */\nexport interface InvariantAllowanceEqualsArgs {\n readonly bind: {\n readonly expectedAmount: Bindable<'resource'>;\n readonly owner: Bindable<'address'>;\n readonly spender: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert that a spender is permitted to move at most a maximum allowance on behalf of an owner */\nexport interface InvariantAllowanceAtMostArgs {\n readonly bind: {\n readonly maximumAmount: Bindable<'resource'>;\n readonly owner: Bindable<'address'>;\n readonly spender: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert that a spender's allowance on behalf of an owner is between a minimum and a maximum (inclusive) */\nexport interface InvariantAllowanceInRangeArgs {\n readonly bind: {\n readonly minimumAmount: Bindable<'resource'>;\n readonly maximumAmount: Bindable<'uint256'>;\n readonly owner: Bindable<'address'>;\n readonly spender: Bindable<'address'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert a uint256 value satisfies a comparison against a constant threshold; reverts on violation */\nexport interface InvariantNumericArgs {\n readonly bind: {\n readonly value: Bindable<'uint256'>;\n };\n readonly config: InvariantNumericConfig;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert min <= value <= max against constant bounds; reverts if outside the range */\nexport interface InvariantNumericInRangeArgs {\n readonly bind: {\n readonly value: Bindable<'uint256'>;\n };\n readonly config: InvariantNumericInRangeConfig;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Add two unsigned integers (a + b) */\nexport interface CoreAddArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Subtract b from a (a - b); reverts on underflow */\nexport interface CoreSubtractArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Multiply two unsigned integers (a * b) */\nexport interface CoreMultiplyArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Divide a by b, rounding toward zero */\nexport interface CoreDivideDownArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Divide a by b, rounding away from zero */\nexport interface CoreDivideUpArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Multiply value by basis points and divide by 10000, rounding down */\nexport interface CoreBpsDownArgs {\n readonly bind: {\n readonly value: Bindable<'uint256'>;\n };\n readonly config: CoreBpsDownConfig;\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Multiply value by basis points and divide by 10000, rounding up */\nexport interface CoreBpsUpArgs {\n readonly bind: {\n readonly value: Bindable<'uint256'>;\n };\n readonly config: CoreBpsUpConfig;\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Assert a == b; reverts if not equal */\nexport interface CoreAssertEqualArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert a != b; reverts if equal */\nexport interface CoreAssertNotEqualArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert a > b; reverts if a <= b */\nexport interface CoreAssertGtArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert a >= b; reverts if a < b */\nexport interface CoreAssertGteArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert a < b; reverts if a >= b */\nexport interface CoreAssertLtArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert a <= b; reverts if a > b */\nexport interface CoreAssertLteArgs {\n readonly bind: {\n readonly a: Bindable<'uint256'>;\n readonly b: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Assert min <= value <= max; reverts if value is outside the range */\nexport interface CoreAssertInRangeArgs {\n readonly bind: {\n readonly value: Bindable<'uint256'>;\n readonly min: Bindable<'uint256'>;\n readonly max: Bindable<'uint256'>;\n };\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Approve an ERC20 spender for the given token and amount */\nexport interface CoreApproveArgs {\n readonly bind: {\n readonly amount: Bindable<'resource'>;\n };\n readonly config: CoreApproveConfig;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Read an ERC20 balance, producing a resource */\nexport interface CoreBalanceOfArgs {\n readonly bind: Record;\n readonly config: CoreBalanceOfConfig;\n readonly guards?: readonly TypedGuard<'balance'>[];\n}\n\n/** Transfer tokens to a recipient address, optionally specifying a partial amount */\nexport interface CoreTransferArgs {\n readonly bind: {\n readonly amount: Bindable<'resource'>;\n readonly recipient: Bindable<'address'>;\n };\n readonly config: CoreTransferConfig;\n readonly guards?: readonly TypedGuard<'transferred' | 'remainder'>[];\n}\n\n/** Emit a custom on-chain event carrying 1 32-byte payload value. The value becomes a non-indexed data word in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */\nexport interface CoreEmitEvent1Args {\n readonly bind: {\n readonly value0: Bindable<'bytes32'>;\n };\n readonly config: CoreEmitEvent1Config;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Emit a custom on-chain event carrying 2 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */\nexport interface CoreEmitEvent2Args {\n readonly bind: {\n readonly value0: Bindable<'bytes32'>;\n readonly value1: Bindable<'bytes32'>;\n };\n readonly config: CoreEmitEvent2Config;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Emit a custom on-chain event carrying 3 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */\nexport interface CoreEmitEvent3Args {\n readonly bind: {\n readonly value0: Bindable<'bytes32'>;\n readonly value1: Bindable<'bytes32'>;\n readonly value2: Bindable<'bytes32'>;\n };\n readonly config: CoreEmitEvent3Config;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Emit a custom on-chain event carrying 4 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). */\nexport interface CoreEmitEvent4Args {\n readonly bind: {\n readonly value0: Bindable<'bytes32'>;\n readonly value1: Bindable<'bytes32'>;\n readonly value2: Bindable<'bytes32'>;\n readonly value3: Bindable<'bytes32'>;\n };\n readonly config: CoreEmitEvent4Config;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Invoke a smart contract function, optionally spending a token resource */\nexport interface CoreCallArgs {\n readonly resource?: Bindable<'resource'>;\n readonly bind: SignatureBind;\n readonly config: Omit & {\n readonly functionSignature: TSig;\n };\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Read from a smart contract at runtime (StaticCall); result is fresh at execution time */\nexport interface CoreStaticCallArgs {\n readonly bind: SignatureBind;\n readonly config: Omit & {\n readonly functionSignature: TSig;\n };\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Invoke a contract with pre-encoded calldata */\nexport interface CoreRawCallArgs {\n readonly bind: Record;\n readonly config: CoreRawCallConfig;\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\n/** Graduate a raw handle to a resource, enabling slippage surfacing and linearity tracking */\nexport interface CoreAsResourceArgs {\n readonly bind: {\n readonly handle: Bindable<'uint256'>;\n };\n readonly config: CoreAsResourceConfig;\n readonly guards?: readonly TypedGuard<'resource'>[];\n}\n\n/** Borrow an asset from an Aave v3 pool against existing collateral, exposing the borrowed asset as a Resource */\nexport interface AaveBorrowArgs {\n readonly bind: Record;\n readonly config: AaveBorrowConfig;\n readonly guards?: readonly TypedGuard<'debtBalance'>[];\n}\n\n/** Repay an Aave v3 variable-rate debt position with the supplied asset. mode: 'exact' passes the input handle amount; mode: 'max' passes type(uint256).max so Aave's Pool clamps paybackAmount to userVariableDebt exactly. Any unspent input is returned through the residual port. */\nexport interface AaveRepayArgs {\n readonly bind: {\n readonly assetIn: Bindable<'resource'>;\n readonly onBehalfOf: Bindable<'address'>;\n };\n readonly config: AaveRepayConfig;\n readonly guards?: readonly TypedGuard<'actualRepaid' | 'residual'>[];\n}\n\n/** Repay an Aave v3 variable-rate debt by burning the caller's aToken balance, returning any unspent residual */\nexport interface AaveRepayWithATokensArgs {\n readonly bind: {\n readonly aTokenIn: Bindable<'resource'>;\n };\n readonly config: AaveRepayWithATokensConfig;\n readonly guards?: readonly TypedGuard<'actualRepaid' | 'residual'>[];\n}\n\n/** Claim a specific Aave v3 incentives reward token against a set of receipt-token positions, exposing the claimed amount as a Resource */\nexport interface AaveClaimRewardsArgs {\n readonly bind: Record;\n readonly config: AaveClaimRewardsConfig;\n readonly guards?: readonly TypedGuard<'claimedAmount'>[];\n}\n\n/** Switch the executionAddress's Aave v3 eMode category. 0 disables eMode. The pool reverts if the switch would make the position unhealthy or if any open borrow is for an asset outside the target category. */\nexport interface AaveSetEModeArgs {\n readonly bind: Record;\n readonly config: AaveSetEModeConfig;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). */\nexport interface MorphoBlueSupplyCollateralArgs {\n readonly bind: {\n readonly assetIn: Bindable<'resource'>;\n };\n readonly config: MorphoBlueSupplyCollateralConfig;\n readonly guards?: readonly TypedGuard[];\n}\n\n/** Withdraw collateral from a Morpho Blue market position to the receiver address. Exposes the withdrawn ERC20 amount as a Resource output. */\nexport interface MorphoBlueWithdrawCollateralArgs {\n readonly bind: Record;\n readonly config: MorphoBlueWithdrawCollateralConfig;\n readonly guards?: readonly TypedGuard<'collateralWithdrawn'>[];\n}\n\n/** Route tokens into a DeFi protocol position via the edge catalog */\nexport interface LifiZapArgs {\n readonly bind: {\n readonly amountIn: Bindable<'resource'>;\n };\n readonly config: LifiZapConfig;\n readonly guards?: readonly TypedGuard<'amountOut'>[];\n}\n\n/** Exact-output (BUY) swap via the Paraswap/Velora Market API: produce exactly `exactAmountOut` of the destination token, pulling only the source needed and exposing the genuinely-unspent source as `unspentIn`. */\nexport interface ParaswapBuyArgs {\n readonly bind: {\n readonly amountIn: Bindable<'resource'>;\n };\n readonly config: ParaswapBuyConfig;\n readonly guards?: readonly TypedGuard<'unspentIn'>[];\n}\n\n/** Read a smart contract value at compile time (off-chain eth_call); result is baked as a literal */\nexport interface CorePeekArgs {\n readonly bind: Record;\n readonly config: CorePeekConfig;\n readonly guards?: readonly TypedGuard<'result'>[];\n}\n\nexport interface CoreSplitOutputs {\n readonly a: OutputHandle<'resource'>;\n readonly b: OutputHandle<'resource'>;\n}\n\nexport interface CoreMergeOutputs {\n readonly merged: OutputHandle<'resource'>;\n}\n\nexport interface LifiSwapOutputs {\n readonly amountOut: OutputHandle<'resource'>;\n readonly unspentIn: OutputHandle<'resource'>;\n}\n\nexport interface CoreAddOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreSubtractOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreMultiplyOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreDivideDownOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreDivideUpOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreBpsDownOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreBpsUpOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreBalanceOfOutputs {\n readonly balance: OutputHandle<'resource'>;\n}\n\nexport interface CoreTransferOutputs {\n readonly transferred: OutputHandle<'resource'>;\n readonly remainder: OutputHandle<'resource'>;\n}\n\nexport interface CoreRawCallOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport interface CoreAsResourceOutputs {\n readonly resource: OutputHandle<'resource'>;\n}\n\nexport interface AaveBorrowOutputs {\n readonly borrowed: OutputHandle<'resource'>;\n readonly debtBalance: OutputHandle<'uint256'>;\n}\n\nexport interface AaveRepayOutputs {\n readonly actualRepaid: OutputHandle<'uint256'>;\n readonly residual: OutputHandle<'resource'>;\n}\n\nexport interface AaveRepayWithATokensOutputs {\n readonly actualRepaid: OutputHandle<'uint256'>;\n readonly residual: OutputHandle<'resource'>;\n}\n\nexport interface AaveClaimRewardsOutputs {\n readonly claimed: OutputHandle<'resource'>;\n readonly claimedAmount: OutputHandle<'uint256'>;\n}\n\nexport interface MorphoBlueWithdrawCollateralOutputs {\n readonly withdrawn: OutputHandle<'resource'>;\n readonly collateralWithdrawn: OutputHandle<'uint256'>;\n}\n\nexport interface LifiZapOutputs {\n readonly amountOut: OutputHandle<'resource'>;\n}\n\nexport interface ParaswapBuyOutputs {\n readonly amountOut: OutputHandle<'resource'>;\n readonly unspentIn: OutputHandle<'resource'>;\n}\n\nexport interface CorePeekOutputs {\n readonly result: OutputHandle<'uint256'>;\n}\n\nexport type GeneratedOps = {\n readonly core: {\n /** Split a resource into two outputs by basis-point ratio — original id: \"core.split\" */\n readonly split: (nodeId: string, args: CoreSplitArgs) => CoreSplitOutputs;\n /** Merge two same-token resources into one by addition — original id: \"core.merge\" */\n readonly merge: (nodeId: string, args: CoreMergeArgs) => CoreMergeOutputs;\n /** Add two unsigned integers (a + b) — original id: \"core.add\" */\n readonly add: (nodeId: string, args: CoreAddArgs) => CoreAddOutputs;\n /** Subtract b from a (a - b); reverts on underflow — original id: \"core.subtract\" */\n readonly subtract: (\n nodeId: string,\n args: CoreSubtractArgs,\n ) => CoreSubtractOutputs;\n /** Multiply two unsigned integers (a * b) — original id: \"core.multiply\" */\n readonly multiply: (\n nodeId: string,\n args: CoreMultiplyArgs,\n ) => CoreMultiplyOutputs;\n /** Divide a by b, rounding toward zero — original id: \"core.divideDown\" */\n readonly divideDown: (\n nodeId: string,\n args: CoreDivideDownArgs,\n ) => CoreDivideDownOutputs;\n /** Divide a by b, rounding away from zero — original id: \"core.divideUp\" */\n readonly divideUp: (\n nodeId: string,\n args: CoreDivideUpArgs,\n ) => CoreDivideUpOutputs;\n /** Multiply value by basis points and divide by 10000, rounding down — original id: \"core.bpsDown\" */\n readonly bpsDown: (\n nodeId: string,\n args: CoreBpsDownArgs,\n ) => CoreBpsDownOutputs;\n /** Multiply value by basis points and divide by 10000, rounding up — original id: \"core.bpsUp\" */\n readonly bpsUp: (nodeId: string, args: CoreBpsUpArgs) => CoreBpsUpOutputs;\n /** Assert a == b; reverts if not equal — original id: \"core.assertEqual\" */\n readonly assertEqual: (nodeId: string, args: CoreAssertEqualArgs) => void;\n /** Assert a != b; reverts if equal — original id: \"core.assertNotEqual\" */\n readonly assertNotEqual: (\n nodeId: string,\n args: CoreAssertNotEqualArgs,\n ) => void;\n /** Assert a > b; reverts if a <= b — original id: \"core.assertGt\" */\n readonly assertGt: (nodeId: string, args: CoreAssertGtArgs) => void;\n /** Assert a >= b; reverts if a < b — original id: \"core.assertGte\" */\n readonly assertGte: (nodeId: string, args: CoreAssertGteArgs) => void;\n /** Assert a < b; reverts if a >= b — original id: \"core.assertLt\" */\n readonly assertLt: (nodeId: string, args: CoreAssertLtArgs) => void;\n /** Assert a <= b; reverts if a > b — original id: \"core.assertLte\" */\n readonly assertLte: (nodeId: string, args: CoreAssertLteArgs) => void;\n /** Assert min <= value <= max; reverts if value is outside the range — original id: \"core.assertInRange\" */\n readonly assertInRange: (\n nodeId: string,\n args: CoreAssertInRangeArgs,\n ) => void;\n /** Approve an ERC20 spender for the given token and amount — original id: \"core.approve\" */\n readonly approve: (nodeId: string, args: CoreApproveArgs) => void;\n /** Read an ERC20 balance, producing a resource — original id: \"core.balanceOf\" */\n readonly balanceOf: (\n nodeId: string,\n args: CoreBalanceOfArgs,\n ) => CoreBalanceOfOutputs;\n /** Transfer tokens to a recipient address, optionally specifying a partial amount — original id: \"core.transfer\" */\n readonly transfer: (\n nodeId: string,\n args: CoreTransferArgs,\n ) => CoreTransferOutputs;\n /** Emit a custom on-chain event carrying 1 32-byte payload value. The value becomes a non-indexed data word in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: \"core.emitEvent1\" */\n readonly emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) => void;\n /** Emit a custom on-chain event carrying 2 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: \"core.emitEvent2\" */\n readonly emitEvent2: (nodeId: string, args: CoreEmitEvent2Args) => void;\n /** Emit a custom on-chain event carrying 3 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: \"core.emitEvent3\" */\n readonly emitEvent3: (nodeId: string, args: CoreEmitEvent3Args) => void;\n /** Emit a custom on-chain event carrying 4 32-byte payload values. The values become non-indexed data words in a fixed VM log event; the signature is hashed into a discriminator word (it is NOT an indexed EVM topic). — original id: \"core.emitEvent4\" */\n readonly emitEvent4: (nodeId: string, args: CoreEmitEvent4Args) => void;\n /** Invoke a smart contract function, optionally spending a token resource — original id: \"core.call\" */\n readonly call: (\n nodeId: string,\n args: CoreCallArgs,\n ) => CoreCallResult;\n /** Read from a smart contract at runtime (StaticCall); result is fresh at execution time — original id: \"core.staticCall\" */\n readonly staticCall: (\n nodeId: string,\n args: CoreStaticCallArgs,\n ) => StaticCallResult;\n /** Invoke a contract with pre-encoded calldata — original id: \"core.rawCall\" */\n readonly rawCall: (\n nodeId: string,\n args: CoreRawCallArgs,\n ) => CoreRawCallOutputs;\n /** Graduate a raw handle to a resource, enabling slippage surfacing and linearity tracking — original id: \"core.asResource\" */\n readonly asResource: (\n nodeId: string,\n args: CoreAsResourceArgs,\n ) => CoreAsResourceOutputs;\n /** Read a smart contract value at compile time (off-chain eth_call); result is baked as a literal — original id: \"core.peek\" */\n readonly peek: (nodeId: string, args: CorePeekArgs) => CorePeekOutputs;\n };\n readonly lifi: {\n /** Swap tokens via the LI.FI aggregator API — original id: \"lifi.swap\" */\n readonly swap: (nodeId: string, args: LifiSwapArgs) => LifiSwapOutputs;\n /** Route tokens into a DeFi protocol position via the edge catalog — original id: \"lifi.zap\" */\n readonly zap: (nodeId: string, args: LifiZapArgs) => LifiZapOutputs;\n };\n readonly invariant: {\n /** Assert that an account holds at least a minimum token balance — original id: \"invariant.balanceAtLeast\" */\n readonly balanceAtLeast: (\n nodeId: string,\n args: InvariantBalanceAtLeastArgs,\n ) => void;\n /** Assert that an account holds exactly an expected token balance — original id: \"invariant.balanceEquals\" */\n readonly balanceEquals: (\n nodeId: string,\n args: InvariantBalanceEqualsArgs,\n ) => void;\n /** Assert that an account holds at most a maximum token balance — original id: \"invariant.balanceAtMost\" */\n readonly balanceAtMost: (\n nodeId: string,\n args: InvariantBalanceAtMostArgs,\n ) => void;\n /** Assert that an account's token balance is between a minimum and a maximum (inclusive) — original id: \"invariant.balanceInRange\" */\n readonly balanceInRange: (\n nodeId: string,\n args: InvariantBalanceInRangeArgs,\n ) => void;\n /** Assert that a spender is permitted to move at least a minimum allowance on behalf of an owner — original id: \"invariant.allowanceAtLeast\" */\n readonly allowanceAtLeast: (\n nodeId: string,\n args: InvariantAllowanceAtLeastArgs,\n ) => void;\n /** Assert that a spender's allowance on behalf of an owner exactly equals an expected amount — original id: \"invariant.allowanceEquals\" */\n readonly allowanceEquals: (\n nodeId: string,\n args: InvariantAllowanceEqualsArgs,\n ) => void;\n /** Assert that a spender is permitted to move at most a maximum allowance on behalf of an owner — original id: \"invariant.allowanceAtMost\" */\n readonly allowanceAtMost: (\n nodeId: string,\n args: InvariantAllowanceAtMostArgs,\n ) => void;\n /** Assert that a spender's allowance on behalf of an owner is between a minimum and a maximum (inclusive) — original id: \"invariant.allowanceInRange\" */\n readonly allowanceInRange: (\n nodeId: string,\n args: InvariantAllowanceInRangeArgs,\n ) => void;\n /** Assert a uint256 value satisfies a comparison against a constant threshold; reverts on violation — original id: \"invariant.numeric\" */\n readonly numeric: (nodeId: string, args: InvariantNumericArgs) => void;\n /** Assert min <= value <= max against constant bounds; reverts if outside the range — original id: \"invariant.numericInRange\" */\n readonly numericInRange: (\n nodeId: string,\n args: InvariantNumericInRangeArgs,\n ) => void;\n };\n readonly aave: {\n /** Borrow an asset from an Aave v3 pool against existing collateral, exposing the borrowed asset as a Resource — original id: \"aave.borrow\" */\n readonly borrow: (\n nodeId: string,\n args: AaveBorrowArgs,\n ) => AaveBorrowOutputs;\n /** Repay an Aave v3 variable-rate debt position with the supplied asset. mode: 'exact' passes the input handle amount; mode: 'max' passes type(uint256).max so Aave's Pool clamps paybackAmount to userVariableDebt exactly. Any unspent input is returned through the residual port. — original id: \"aave.repay\" */\n readonly repay: (nodeId: string, args: AaveRepayArgs) => AaveRepayOutputs;\n /** Repay an Aave v3 variable-rate debt by burning the caller's aToken balance, returning any unspent residual — original id: \"aave.repayWithATokens\" */\n readonly repayWithATokens: (\n nodeId: string,\n args: AaveRepayWithATokensArgs,\n ) => AaveRepayWithATokensOutputs;\n /** Claim a specific Aave v3 incentives reward token against a set of receipt-token positions, exposing the claimed amount as a Resource — original id: \"aave.claimRewards\" */\n readonly claimRewards: (\n nodeId: string,\n args: AaveClaimRewardsArgs,\n ) => AaveClaimRewardsOutputs;\n /** Switch the executionAddress's Aave v3 eMode category. 0 disables eMode. The pool reverts if the switch would make the position unhealthy or if any open borrow is for an asset outside the target category. — original id: \"aave.setEMode\" */\n readonly setEMode: (nodeId: string, args: AaveSetEModeArgs) => void;\n };\n readonly morphoBlue: {\n /** Deposit the collateral asset of a Morpho Blue market on behalf of the execution proxy. mode: 'exact' pulls the input handle's amount. mode: 'all' reads the proxy's current ERC20 balance of the market's collateral token and pulls that amount, ignoring the input handle's literal value — note this pulls the proxy's total balance (including unrelated upstream residuals), not just the input port's delivery. Credits Position.collateral on the Morpho singleton; emits no return value and exposes no resource output (the collateral is non-transferable accounting state). — original id: \"morphoBlue.supplyCollateral\" */\n readonly supplyCollateral: (\n nodeId: string,\n args: MorphoBlueSupplyCollateralArgs,\n ) => void;\n /** Withdraw collateral from a Morpho Blue market position to the receiver address. Exposes the withdrawn ERC20 amount as a Resource output. — original id: \"morphoBlue.withdrawCollateral\" */\n readonly withdrawCollateral: (\n nodeId: string,\n args: MorphoBlueWithdrawCollateralArgs,\n ) => MorphoBlueWithdrawCollateralOutputs;\n };\n readonly paraswap: {\n /** Exact-output (BUY) swap via the Paraswap/Velora Market API: produce exactly `exactAmountOut` of the destination token, pulling only the source needed and exposing the genuinely-unspent source as `unspentIn`. — original id: \"paraswap.buy\" */\n readonly buy: (nodeId: string, args: ParaswapBuyArgs) => ParaswapBuyOutputs;\n };\n};\n\nexport const bindGeneratedOps = (\n builder: FlowBuilderInternal,\n): GeneratedOps => ({\n core: {\n split: (nodeId: string, args: CoreSplitArgs) =>\n builder.call(nodeId, 'core.split', args, {\n a: 'resource',\n b: 'resource',\n } as const),\n merge: (nodeId: string, args: CoreMergeArgs) =>\n builder.call(nodeId, 'core.merge', { ...args, config: {} }, {\n merged: 'resource',\n } as const),\n add: (nodeId: string, args: CoreAddArgs) =>\n builder.call(nodeId, 'core.add', { ...args, config: {} }, {\n result: 'uint256',\n } as const),\n subtract: (nodeId: string, args: CoreSubtractArgs) =>\n builder.call(nodeId, 'core.subtract', { ...args, config: {} }, {\n result: 'uint256',\n } as const),\n multiply: (nodeId: string, args: CoreMultiplyArgs) =>\n builder.call(nodeId, 'core.multiply', { ...args, config: {} }, {\n result: 'uint256',\n } as const),\n divideDown: (nodeId: string, args: CoreDivideDownArgs) =>\n builder.call(nodeId, 'core.divideDown', { ...args, config: {} }, {\n result: 'uint256',\n } as const),\n divideUp: (nodeId: string, args: CoreDivideUpArgs) =>\n builder.call(nodeId, 'core.divideUp', { ...args, config: {} }, {\n result: 'uint256',\n } as const),\n bpsDown: (nodeId: string, args: CoreBpsDownArgs) =>\n builder.call(nodeId, 'core.bpsDown', args, {\n result: 'uint256',\n } as const),\n bpsUp: (nodeId: string, args: CoreBpsUpArgs) =>\n builder.call(nodeId, 'core.bpsUp', args, { result: 'uint256' } as const),\n assertEqual: (nodeId: string, args: CoreAssertEqualArgs) =>\n builder.call(nodeId, 'core.assertEqual', { ...args, config: {} }, {}),\n assertNotEqual: (nodeId: string, args: CoreAssertNotEqualArgs) =>\n builder.call(nodeId, 'core.assertNotEqual', { ...args, config: {} }, {}),\n assertGt: (nodeId: string, args: CoreAssertGtArgs) =>\n builder.call(nodeId, 'core.assertGt', { ...args, config: {} }, {}),\n assertGte: (nodeId: string, args: CoreAssertGteArgs) =>\n builder.call(nodeId, 'core.assertGte', { ...args, config: {} }, {}),\n assertLt: (nodeId: string, args: CoreAssertLtArgs) =>\n builder.call(nodeId, 'core.assertLt', { ...args, config: {} }, {}),\n assertLte: (nodeId: string, args: CoreAssertLteArgs) =>\n builder.call(nodeId, 'core.assertLte', { ...args, config: {} }, {}),\n assertInRange: (nodeId: string, args: CoreAssertInRangeArgs) =>\n builder.call(nodeId, 'core.assertInRange', { ...args, config: {} }, {}),\n approve: (nodeId: string, args: CoreApproveArgs) =>\n builder.call(nodeId, 'core.approve', args, {}),\n balanceOf: (nodeId: string, args: CoreBalanceOfArgs) =>\n builder.call(nodeId, 'core.balanceOf', args, {\n balance: 'resource',\n } as const),\n transfer: (nodeId: string, args: CoreTransferArgs) =>\n builder.call(nodeId, 'core.transfer', args, {\n transferred: 'resource',\n remainder: 'resource',\n } as const),\n emitEvent1: (nodeId: string, args: CoreEmitEvent1Args) =>\n builder.call(nodeId, 'core.emitEvent1', args, {}),\n emitEvent2: (nodeId: string, args: CoreEmitEvent2Args) =>\n builder.call(nodeId, 'core.emitEvent2', args, {}),\n emitEvent3: (nodeId: string, args: CoreEmitEvent3Args) =>\n builder.call(nodeId, 'core.emitEvent3', args, {}),\n emitEvent4: (nodeId: string, args: CoreEmitEvent4Args) =>\n builder.call(nodeId, 'core.emitEvent4', args, {}),\n call: (nodeId: string, args: CoreCallArgs) => {\n const wire = buildCallWireFormat({\n resource: args.resource,\n bind: args.bind as Record,\n config: args.config as Record,\n guards: args.guards,\n });\n return builder.call(nodeId, wire.op, wire, {\n result: 'uint256',\n } as const) as unknown as CoreCallResult;\n },\n staticCall: (\n nodeId: string,\n args: CoreStaticCallArgs,\n ) =>\n builder.call(\n nodeId,\n 'core.staticCall',\n buildStaticCallWireFormat({\n bind: args.bind as Record,\n config: args.config as Record,\n guards: args.guards,\n }),\n { result: 'uint256' } as const,\n ) as unknown as StaticCallResult,\n rawCall: (nodeId: string, args: CoreRawCallArgs) =>\n builder.call(nodeId, 'core.rawCall', args, {\n result: 'uint256',\n } as const),\n asResource: (nodeId: string, args: CoreAsResourceArgs) =>\n builder.call(nodeId, 'core.asResource', args, {\n resource: 'resource',\n } as const),\n peek: (nodeId: string, args: CorePeekArgs) =>\n builder.call(nodeId, 'core.peek', args, { result: 'uint256' } as const),\n },\n lifi: {\n swap: (nodeId: string, args: LifiSwapArgs) =>\n builder.call(nodeId, 'lifi.swap', args, {\n amountOut: 'resource',\n unspentIn: 'resource',\n } as const),\n zap: (nodeId: string, args: LifiZapArgs) =>\n builder.call(nodeId, 'lifi.zap', args, {\n amountOut: 'resource',\n } as const),\n },\n invariant: {\n balanceAtLeast: (nodeId: string, args: InvariantBalanceAtLeastArgs) =>\n builder.call(\n nodeId,\n 'invariant.balanceAtLeast',\n { ...args, config: {} },\n {},\n ),\n balanceEquals: (nodeId: string, args: InvariantBalanceEqualsArgs) =>\n builder.call(\n nodeId,\n 'invariant.balanceEquals',\n { ...args, config: {} },\n {},\n ),\n balanceAtMost: (nodeId: string, args: InvariantBalanceAtMostArgs) =>\n builder.call(\n nodeId,\n 'invariant.balanceAtMost',\n { ...args, config: {} },\n {},\n ),\n balanceInRange: (nodeId: string, args: InvariantBalanceInRangeArgs) =>\n builder.call(\n nodeId,\n 'invariant.balanceInRange',\n { ...args, config: {} },\n {},\n ),\n allowanceAtLeast: (nodeId: string, args: InvariantAllowanceAtLeastArgs) =>\n builder.call(\n nodeId,\n 'invariant.allowanceAtLeast',\n { ...args, config: {} },\n {},\n ),\n allowanceEquals: (nodeId: string, args: InvariantAllowanceEqualsArgs) =>\n builder.call(\n nodeId,\n 'invariant.allowanceEquals',\n { ...args, config: {} },\n {},\n ),\n allowanceAtMost: (nodeId: string, args: InvariantAllowanceAtMostArgs) =>\n builder.call(\n nodeId,\n 'invariant.allowanceAtMost',\n { ...args, config: {} },\n {},\n ),\n allowanceInRange: (nodeId: string, args: InvariantAllowanceInRangeArgs) =>\n builder.call(\n nodeId,\n 'invariant.allowanceInRange',\n { ...args, config: {} },\n {},\n ),\n numeric: (nodeId: string, args: InvariantNumericArgs) =>\n builder.call(nodeId, 'invariant.numeric', args, {}),\n numericInRange: (nodeId: string, args: InvariantNumericInRangeArgs) =>\n builder.call(nodeId, 'invariant.numericInRange', args, {}),\n },\n aave: {\n borrow: (nodeId: string, args: AaveBorrowArgs) =>\n builder.call(nodeId, 'aave.borrow', args, {\n borrowed: 'resource',\n debtBalance: 'uint256',\n } as const),\n repay: (nodeId: string, args: AaveRepayArgs) =>\n builder.call(nodeId, 'aave.repay', args, {\n actualRepaid: 'uint256',\n residual: 'resource',\n } as const),\n repayWithATokens: (nodeId: string, args: AaveRepayWithATokensArgs) =>\n builder.call(nodeId, 'aave.repayWithATokens', args, {\n actualRepaid: 'uint256',\n residual: 'resource',\n } as const),\n claimRewards: (nodeId: string, args: AaveClaimRewardsArgs) =>\n builder.call(nodeId, 'aave.claimRewards', args, {\n claimed: 'resource',\n claimedAmount: 'uint256',\n } as const),\n setEMode: (nodeId: string, args: AaveSetEModeArgs) =>\n builder.call(nodeId, 'aave.setEMode', args, {}),\n },\n morphoBlue: {\n supplyCollateral: (nodeId: string, args: MorphoBlueSupplyCollateralArgs) =>\n builder.call(nodeId, 'morphoBlue.supplyCollateral', args, {}),\n withdrawCollateral: (\n nodeId: string,\n args: MorphoBlueWithdrawCollateralArgs,\n ) =>\n builder.call(nodeId, 'morphoBlue.withdrawCollateral', args, {\n withdrawn: 'resource',\n collateralWithdrawn: 'uint256',\n } as const),\n },\n paraswap: {\n buy: (nodeId: string, args: ParaswapBuyArgs) =>\n builder.call(nodeId, 'paraswap.buy', args, {\n amountOut: 'resource',\n unspentIn: 'resource',\n } as const),\n },\n});\n"],"mappings":"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","names":[]}