@lifi/composer-sdk/dist/generated/operations.generated.js

Public Composer SDK for building and submitting flows

import {
  buildCallWireFormat,
  buildStaticCallWireFormat
} from "../authoring/signatureArgs.js";
const bindGeneratedOps = (builder) => ({
  core: {
    split: (nodeId, args) => builder.call(nodeId, "core.split", args, {
      a: "resource",
      b: "resource"
    }),
    merge: (nodeId, args) => builder.call(nodeId, "core.merge", { ...args, config: {} }, {
      merged: "resource"
    }),
    add: (nodeId, args) => builder.call(nodeId, "core.add", { ...args, config: {} }, {
      result: "uint256"
    }),
    subtract: (nodeId, args) => builder.call(nodeId, "core.subtract", { ...args, config: {} }, {
      result: "uint256"
    }),
    multiply: (nodeId, args) => builder.call(nodeId, "core.multiply", { ...args, config: {} }, {
      result: "uint256"
    }),
    divideDown: (nodeId, args) => builder.call(nodeId, "core.divideDown", { ...args, config: {} }, {
      result: "uint256"
    }),
    divideUp: (nodeId, args) => builder.call(nodeId, "core.divideUp", { ...args, config: {} }, {
      result: "uint256"
    }),
    bpsDown: (nodeId, args) => builder.call(nodeId, "core.bpsDown", args, {
      result: "uint256"
    }),
    bpsUp: (nodeId, args) => builder.call(nodeId, "core.bpsUp", args, { result: "uint256" }),
    assertEqual: (nodeId, args) => builder.call(nodeId, "core.assertEqual", { ...args, config: {} }, {}),
    assertNotEqual: (nodeId, args) => builder.call(nodeId, "core.assertNotEqual", { ...args, config: {} }, {}),
    assertGt: (nodeId, args) => builder.call(nodeId, "core.assertGt", { ...args, config: {} }, {}),
    assertGte: (nodeId, args) => builder.call(nodeId, "core.assertGte", { ...args, config: {} }, {}),
    assertLt: (nodeId, args) => builder.call(nodeId, "core.assertLt", { ...args, config: {} }, {}),
    assertLte: (nodeId, args) => builder.call(nodeId, "core.assertLte", { ...args, config: {} }, {}),
    assertInRange: (nodeId, args) => builder.call(nodeId, "core.assertInRange", { ...args, config: {} }, {}),
    approve: (nodeId, args) => builder.call(nodeId, "core.approve", args, {}),
    balanceOf: (nodeId, args) => builder.call(nodeId, "core.balanceOf", args, {
      balance: "resource"
    }),
    transfer: (nodeId, args) => builder.call(nodeId, "core.transfer", args, {
      transferred: "resource",
      remainder: "resource"
    }),
    emitEvent1: (nodeId, args) => builder.call(nodeId, "core.emitEvent1", args, {}),
    emitEvent2: (nodeId, args) => builder.call(nodeId, "core.emitEvent2", args, {}),
    emitEvent3: (nodeId, args) => builder.call(nodeId, "core.emitEvent3", args, {}),
    emitEvent4: (nodeId, args) => builder.call(nodeId, "core.emitEvent4", args, {}),
    call: (nodeId, args) => {
      const wire = buildCallWireFormat({
        resource: args.resource,
        bind: args.bind,
        config: args.config,
        guards: args.guards
      });
      return builder.call(nodeId, wire.op, wire, {
        result: "uint256"
      });
    },
    staticCall: (nodeId, args) => builder.call(
      nodeId,
      "core.staticCall",
      buildStaticCallWireFormat({
        bind: args.bind,
        config: args.config,
        guards: args.guards
      }),
      { result: "uint256" }
    ),
    rawCall: (nodeId, args) => builder.call(nodeId, "core.rawCall", args, {
      result: "uint256"
    }),
    asResource: (nodeId, args) => builder.call(nodeId, "core.asResource", args, {
      resource: "resource"
    }),
    peek: (nodeId, args) => builder.call(nodeId, "core.peek", args, { result: "uint256" })
  },
  lifi: {
    swap: (nodeId, args) => builder.call(nodeId, "lifi.swap", args, {
      amountOut: "resource",
      unspentIn: "resource"
    }),
    zap: (nodeId, args) => builder.call(nodeId, "lifi.zap", args, {
      amountOut: "resource"
    })
  },
  invariant: {
    balanceAtLeast: (nodeId, args) => builder.call(
      nodeId,
      "invariant.balanceAtLeast",
      { ...args, config: {} },
      {}
    ),
    balanceEquals: (nodeId, args) => builder.call(
      nodeId,
      "invariant.balanceEquals",
      { ...args, config: {} },
      {}
    ),
    balanceAtMost: (nodeId, args) => builder.call(
      nodeId,
      "invariant.balanceAtMost",
      { ...args, config: {} },
      {}
    ),
    balanceInRange: (nodeId, args) => builder.call(
      nodeId,
      "invariant.balanceInRange",
      { ...args, config: {} },
      {}
    ),
    allowanceAtLeast: (nodeId, args) => builder.call(
      nodeId,
      "invariant.allowanceAtLeast",
      { ...args, config: {} },
      {}
    ),
    allowanceEquals: (nodeId, args) => builder.call(
      nodeId,
      "invariant.allowanceEquals",
      { ...args, config: {} },
      {}
    ),
    allowanceAtMost: (nodeId, args) => builder.call(
      nodeId,
      "invariant.allowanceAtMost",
      { ...args, config: {} },
      {}
    ),
    allowanceInRange: (nodeId, args) => builder.call(
      nodeId,
      "invariant.allowanceInRange",
      { ...args, config: {} },
      {}
    ),
    numeric: (nodeId, args) => builder.call(nodeId, "invariant.numeric", args, {}),
    numericInRange: (nodeId, args) => builder.call(nodeId, "invariant.numericInRange", args, {})
  },
  aave: {
    borrow: (nodeId, args) => builder.call(nodeId, "aave.borrow", args, {
      borrowed: "resource",
      debtBalance: "uint256"
    }),
    repay: (nodeId, args) => builder.call(nodeId, "aave.repay", args, {
      actualRepaid: "uint256",
      residual: "resource"
    }),
    repayWithATokens: (nodeId, args) => builder.call(nodeId, "aave.repayWithATokens", args, {
      actualRepaid: "uint256",
      residual: "resource"
    }),
    claimRewards: (nodeId, args) => builder.call(nodeId, "aave.claimRewards", args, {
      claimed: "resource",
      claimedAmount: "uint256"
    }),
    setEMode: (nodeId, args) => builder.call(nodeId, "aave.setEMode", args, {})
  },
  morphoBlue: {
    supplyCollateral: (nodeId, args) => builder.call(nodeId, "morphoBlue.supplyCollateral", args, {}),
    withdrawCollateral: (nodeId, args) => builder.call(nodeId, "morphoBlue.withdrawCollateral", args, {
      withdrawn: "resource",
      collateralWithdrawn: "uint256"
    })
  },
  paraswap: {
    buy: (nodeId, args) => builder.call(nodeId, "paraswap.buy", args, {
      amountOut: "resource",
      unspentIn: "resource"
    })
  }
});
export {
  bindGeneratedOps
};
//# sourceMappingURL=operations.generated.js.map