@iris-credit/core-sdk 0.0.0

package/lib/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./chain.js"), exports);
+__exportStar(require("./constants.js"), exports);
+__exportStar(require("./addresses.js"), exports);
+__exportStar(require("./signatures/index.js"), exports);
+__exportStar(require("./math/index.js"), exports);
+__exportStar(require("./abis/index.js"), exports);

package/lib/cjs/math/MathLib.d.ts

@@ -0,0 +1,26 @@
+import type { BigIntish } from "../types.js";
+/** Rounding direction for share↔asset conversions. */
+export type RoundingDirection = "Down" | "Up";
+export declare namespace MathLib {
+    const WAD = 1000000000000000000n;
+    const RAY = 1000000000000000000000000000n;
+    const MAX_UINT_256: bigint;
+    const MAX_UINT_160: bigint;
+    const MAX_UINT_128: bigint;
+    const MAX_UINT_48: bigint;
+    function maxUint(nBits: number): bigint;
+    function abs(a: BigIntish): bigint;
+    function min(...xs: BigIntish[]): bigint;
+    function max(...xs: BigIntish[]): bigint;
+    function zeroFloorSub(x: BigIntish, y: BigIntish): bigint;
+    function wMulDown(x: BigIntish, y: BigIntish): bigint;
+    function wMulUp(x: BigIntish, y: BigIntish): bigint;
+    function wMul(x: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
+    function wDivDown(x: BigIntish, y: BigIntish): bigint;
+    function wDivUp(x: BigIntish, y: BigIntish): bigint;
+    function wDiv(x: BigIntish, y: BigIntish, rounding: RoundingDirection): bigint;
+    function mulDivDown(x: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
+    function mulDivUp(x: BigIntish, y: BigIntish, denominator: BigIntish): bigint;
+    function mulDiv(x: BigIntish, y: BigIntish, denominator: BigIntish, rounding: RoundingDirection): bigint;
+    function wToRay(x: BigIntish): bigint;
+}

package/lib/cjs/math/MathLib.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathLib = void 0;
+var MathLib;
+(function (MathLib) {
+    MathLib.WAD = 1000000000000000000n;
+    MathLib.RAY = 1000000000000000000000000000n;
+    MathLib.MAX_UINT_256 = maxUint(256);
+    MathLib.MAX_UINT_160 = maxUint(160);
+    MathLib.MAX_UINT_128 = maxUint(128);
+    MathLib.MAX_UINT_48 = maxUint(48);
+    function maxUint(nBits) {
+        if (nBits % 4 !== 0)
+            throw new Error(`Invalid number of bits: ${nBits}`);
+        return BigInt(`0x${"f".repeat(nBits / 4)}`);
+    }
+    MathLib.maxUint = maxUint;
+    function abs(a) {
+        a = BigInt(a);
+        return a >= 0 ? a : -a;
+    }
+    MathLib.abs = abs;
+    function min(...xs) {
+        return xs.map(BigInt).reduce((x, y) => (x <= y ? x : y));
+    }
+    MathLib.min = min;
+    function max(...xs) {
+        return xs.map(BigInt).reduce((x, y) => (x <= y ? y : x));
+    }
+    MathLib.max = max;
+    function zeroFloorSub(x, y) {
+        x = BigInt(x);
+        y = BigInt(y);
+        return x <= y ? 0n : x - y;
+    }
+    MathLib.zeroFloorSub = zeroFloorSub;
+    function wMulDown(x, y) {
+        return MathLib.wMul(x, y, "Down");
+    }
+    MathLib.wMulDown = wMulDown;
+    function wMulUp(x, y) {
+        return MathLib.wMul(x, y, "Up");
+    }
+    MathLib.wMulUp = wMulUp;
+    function wMul(x, y, rounding) {
+        return MathLib.mulDiv(x, y, MathLib.WAD, rounding);
+    }
+    MathLib.wMul = wMul;
+    function wDivDown(x, y) {
+        return MathLib.wDiv(x, y, "Down");
+    }
+    MathLib.wDivDown = wDivDown;
+    function wDivUp(x, y) {
+        return MathLib.wDiv(x, y, "Up");
+    }
+    MathLib.wDivUp = wDivUp;
+    function wDiv(x, y, rounding) {
+        return MathLib.mulDiv(x, MathLib.WAD, y, rounding);
+    }
+    MathLib.wDiv = wDiv;
+    function mulDivDown(x, y, denominator) {
+        x = BigInt(x);
+        y = BigInt(y);
+        denominator = BigInt(denominator);
+        if (denominator === 0n)
+            throw Error("MathLib: DIVISION_BY_ZERO");
+        return (x * y) / denominator;
+    }
+    MathLib.mulDivDown = mulDivDown;
+    function mulDivUp(x, y, denominator) {
+        x = BigInt(x);
+        y = BigInt(y);
+        denominator = BigInt(denominator);
+        if (denominator === 0n)
+            throw Error("MathLib: DIVISION_BY_ZERO");
+        const roundup = (x * y) % denominator > 0 ? 1n : 0n;
+        return (x * y) / denominator + roundup;
+    }
+    MathLib.mulDivUp = mulDivUp;
+    function mulDiv(x, y, denominator, rounding) {
+        return MathLib[`mulDiv${rounding}`](x, y, denominator);
+    }
+    MathLib.mulDiv = mulDiv;
+    function wToRay(x) {
+        return BigInt(x) * 1000000000n;
+    }
+    MathLib.wToRay = wToRay;
+})(MathLib || (exports.MathLib = MathLib = {}));

package/lib/cjs/math/index.d.ts

@@ -0,0 +1 @@
+export * from "./MathLib.js";

package/lib/cjs/math/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MathLib.js"), exports);

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/cjs/signatures/authorization.d.ts

@@ -0,0 +1,20 @@
+import type { Address } from "viem";
+export type Authorization = {
+    authorizer: Address;
+    authorized: Address;
+    isAuthorized: boolean;
+    nonce: bigint;
+    deadline: bigint;
+};
+export declare const getAuthorizationTypedData: (chainId: 1, authorization: Authorization) => import("viem").MessageDefinition<{
+    Authorization: {
+        name: string;
+        type: string;
+    }[];
+}, "Authorization", "message", "Authorization", {
+    Authorization: {
+        [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+    };
+}, {
+    [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+}>;

package/lib/cjs/signatures/authorization.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthorizationTypedData = void 0;
+const addresses_js_1 = require("../addresses.js");
+const authorizationTypes = {
+    Authorization: [
+        { name: "authorizer", type: "address" },
+        { name: "authorized", type: "address" },
+        { name: "isAuthorized", type: "bool" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+    ],
+};
+const getAuthorizationTypedData = (chainId, authorization) => {
+    return {
+        domain: {
+            chainId,
+            verifyingContract: (0, addresses_js_1.getChainAddresses)(chainId).iris,
+        },
+        types: authorizationTypes,
+        message: authorization,
+        primaryType: "Authorization",
+    };
+};
+exports.getAuthorizationTypedData = getAuthorizationTypedData;

package/lib/cjs/signatures/erc2612.d.ts

@@ -0,0 +1,34 @@
+import type { Address } from "viem";
+import type { ChainId } from "../chain.js";
+/**
+ * The EIP-712 domain of an ERC-20 token that implements EIP-2612.
+ *
+ * Unlike the iris-signed types, the `verifyingContract` here is the token itself,
+ * and `name`/`version` are token-specific — they must be read from the token
+ * (e.g. via `name()` / `eip712Domain()`), not assumed.
+ */
+export type Erc2612Domain = {
+    token: Address;
+    chainId: ChainId;
+    name: string;
+    version?: string;
+};
+export type Erc2612Permit = {
+    owner: Address;
+    spender: Address;
+    value: bigint;
+    nonce: bigint;
+    deadline: bigint;
+};
+export declare const getErc2612PermitTypedData: (domain: Erc2612Domain, permit: Erc2612Permit) => import("viem").MessageDefinition<{
+    Permit: {
+        name: string;
+        type: string;
+    }[];
+}, "Permit", "message", "Permit", {
+    Permit: {
+        [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+    };
+}, {
+    [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+}>;

package/lib/cjs/signatures/erc2612.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErc2612PermitTypedData = void 0;
+const permitTypes = {
+    Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+    ],
+};
+const getErc2612PermitTypedData = (domain, permit) => {
+    return {
+        domain: {
+            name: domain.name,
+            version: domain.version,
+            chainId: domain.chainId,
+            verifyingContract: domain.token,
+        },
+        types: permitTypes,
+        message: permit,
+        primaryType: "Permit",
+    };
+};
+exports.getErc2612PermitTypedData = getErc2612PermitTypedData;

package/lib/cjs/signatures/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./authorization.js";
+export * from "./erc2612.js";
+export * from "./permit2.js";
+export * from "./quote.js";

package/lib/cjs/signatures/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./authorization.js"), exports);
+__exportStar(require("./erc2612.js"), exports);
+__exportStar(require("./permit2.js"), exports);
+__exportStar(require("./quote.js"), exports);

package/lib/cjs/signatures/permit2.d.ts

@@ -0,0 +1,33 @@
+import type { Address } from "viem";
+/** The permit data for a token. */
+export type PermitDetails = {
+    token: Address;
+    amount: bigint;
+    expiration: number;
+    nonce: number;
+};
+/** The permit message signed for a single token allowance. */
+export type PermitSingle = {
+    details: PermitDetails;
+    spender: Address;
+    sigDeadline: bigint;
+};
+export declare const getPermit2PermitTypedData: (chainId: 1, permitSingle: PermitSingle) => import("viem").MessageDefinition<{
+    PermitSingle: {
+        name: string;
+        type: string;
+    }[];
+    PermitDetails: {
+        name: string;
+        type: string;
+    }[];
+}, "PermitSingle", "message", "PermitDetails" | "PermitSingle", {
+    PermitSingle: {
+        [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+    };
+    PermitDetails: {
+        [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+    };
+}, {
+    [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+}>;

package/lib/cjs/signatures/permit2.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermit2PermitTypedData = void 0;
+const addresses_js_1 = require("../addresses.js");
+const index_js_1 = require("../math/index.js");
+const permit2PermitTypes = {
+    PermitSingle: [
+        { name: "details", type: "PermitDetails" },
+        { name: "spender", type: "address" },
+        { name: "sigDeadline", type: "uint256" },
+    ],
+    PermitDetails: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint160" },
+        { name: "expiration", type: "uint48" },
+        { name: "nonce", type: "uint48" },
+    ],
+};
+const getPermit2PermitTypedData = (chainId, permitSingle) => {
+    const { details, spender, sigDeadline } = permitSingle;
+    return {
+        domain: {
+            name: "Permit2",
+            chainId,
+            verifyingContract: (0, addresses_js_1.getChainAddresses)(chainId).permit2,
+        },
+        types: permit2PermitTypes,
+        message: {
+            details: {
+                token: details.token,
+                amount: index_js_1.MathLib.min(details.amount, index_js_1.MathLib.MAX_UINT_160),
+                expiration: index_js_1.MathLib.min(details.expiration, index_js_1.MathLib.MAX_UINT_48),
+                nonce: details.nonce,
+            },
+            spender,
+            sigDeadline,
+        },
+        primaryType: "PermitSingle",
+    };
+};
+exports.getPermit2PermitTypedData = getPermit2PermitTypedData;

package/lib/cjs/signatures/quote.d.ts

@@ -0,0 +1,34 @@
+import type { Address, Hex } from "viem";
+export type Quote = {
+    borrower: Address;
+    solver: Address;
+    receiver: Address;
+    blm: Address;
+    collateralToken: Address;
+    debtToken: Address;
+    collateral: bigint;
+    debt: bigint;
+    fixedRate: bigint;
+    duration: bigint;
+    overdueRate: bigint;
+    overduePeriod: bigint;
+    bond: bigint;
+    bondLltv: bigint;
+    venueBitmap: bigint;
+    venueId: bigint;
+    deadline: bigint;
+    nonce: bigint;
+    data: Hex;
+};
+export declare const getQuoteTypedData: (chainId: 1, quote: Quote) => import("viem").MessageDefinition<{
+    Quote: {
+        name: string;
+        type: string;
+    }[];
+}, "Quote", "message", "Quote", {
+    Quote: {
+        [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+    };
+}, {
+    [x: string]: [`Error: Cannot convert unknown type '${string}' to primitive type.`];
+}>;

package/lib/cjs/signatures/quote.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuoteTypedData = void 0;
+const addresses_js_1 = require("../addresses.js");
+// Field order must match the contract's QUOTE_TYPEHASH; EIP-712 struct hashing is order-sensitive.
+const quoteTypes = {
+    Quote: [
+        { name: "borrower", type: "address" },
+        { name: "solver", type: "address" },
+        { name: "receiver", type: "address" },
+        { name: "blm", type: "address" },
+        { name: "collateralToken", type: "address" },
+        { name: "debtToken", type: "address" },
+        { name: "collateral", type: "uint256" },
+        { name: "debt", type: "uint256" },
+        { name: "fixedRate", type: "uint256" },
+        { name: "duration", type: "uint256" },
+        { name: "overdueRate", type: "uint256" },
+        { name: "overduePeriod", type: "uint256" },
+        { name: "bond", type: "uint256" },
+        { name: "bondLltv", type: "uint256" },
+        { name: "venueBitmap", type: "uint256" },
+        { name: "venueId", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "data", type: "bytes" },
+    ],
+};
+const getQuoteTypedData = (chainId, quote) => {
+    return {
+        domain: {
+            chainId,
+            verifyingContract: (0, addresses_js_1.getChainAddresses)(chainId).iris,
+        },
+        types: quoteTypes,
+        message: quote,
+        primaryType: "Quote",
+    };
+};
+exports.getQuoteTypedData = getQuoteTypedData;

package/lib/cjs/types.d.ts

@@ -0,0 +1,9 @@
+/** The id of a market used on the core contract */
+export type MarketId = `0x${string}` & {
+    readonly __TYPE__: "marketId";
+};
+export type BigIntish = bigint | string | number | boolean;
+export type Loadable<T> = T | undefined;
+export type Failable<T> = T | null;
+export type Fetchable<T> = Failable<Loadable<T>>;
+export declare const isMarketId: (value: unknown) => value is MarketId;

package/lib/cjs/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMarketId = void 0;
+const isMarketId = (value) => {
+    return typeof value === "string" && /^0x[0-9A-Fa-f]{64}$/.test(value);
+};
+exports.isMarketId = isMarketId;

package/lib/esm/abis/blm.d.ts

@@ -0,0 +1,192 @@
+export declare const blmAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "iris";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "IRIS";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract IIris";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "bondRequirement";
+    readonly inputs: readonly [{
+        readonly name: "quote";
+        readonly type: "tuple";
+        readonly internalType: "struct Quote";
+        readonly components: readonly [{
+            readonly name: "borrower";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "solver";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "receiver";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "blm";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "collateralToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "debtToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "collateral";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "debt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "fixedRate";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "duration";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "overdueRate";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "overduePeriod";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "bond";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "bondLltv";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "venueBitmap";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "venueId";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "data";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "intercept";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "setParams";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "newSlope";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "newIntercept";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "slope";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "SetParams";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newSlope";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "newIntercept";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "ParamsTooHigh";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "Unauthorized";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAddress";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAmount";
+    readonly inputs: readonly [];
+}];