@iris-credit/core-sdk 0.0.0

package/lib/esm/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/esm/math/MathLib.js

@@ -0,0 +1,86 @@
+export { MathLib };
+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 || (MathLib = {}));

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

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

package/lib/esm/math/index.js

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

package/lib/esm/package.json

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

package/lib/esm/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/esm/signatures/authorization.js

@@ -0,0 +1,21 @@
+import { getChainAddresses } from "../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" },
+    ],
+};
+export const getAuthorizationTypedData = (chainId, authorization) => {
+    return {
+        domain: {
+            chainId,
+            verifyingContract: getChainAddresses(chainId).iris,
+        },
+        types: authorizationTypes,
+        message: authorization,
+        primaryType: "Authorization",
+    };
+};

package/lib/esm/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/esm/signatures/erc2612.js

@@ -0,0 +1,22 @@
+const permitTypes = {
+    Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+    ],
+};
+export const getErc2612PermitTypedData = (domain, permit) => {
+    return {
+        domain: {
+            name: domain.name,
+            version: domain.version,
+            chainId: domain.chainId,
+            verifyingContract: domain.token,
+        },
+        types: permitTypes,
+        message: permit,
+        primaryType: "Permit",
+    };
+};

package/lib/esm/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/esm/signatures/index.js

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

package/lib/esm/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/esm/signatures/permit2.js

@@ -0,0 +1,37 @@
+import { getChainAddresses } from "../addresses.js";
+import { MathLib } from "../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" },
+    ],
+};
+export const getPermit2PermitTypedData = (chainId, permitSingle) => {
+    const { details, spender, sigDeadline } = permitSingle;
+    return {
+        domain: {
+            name: "Permit2",
+            chainId,
+            verifyingContract: getChainAddresses(chainId).permit2,
+        },
+        types: permit2PermitTypes,
+        message: {
+            details: {
+                token: details.token,
+                amount: MathLib.min(details.amount, MathLib.MAX_UINT_160),
+                expiration: MathLib.min(details.expiration, MathLib.MAX_UINT_48),
+                nonce: details.nonce,
+            },
+            spender,
+            sigDeadline,
+        },
+        primaryType: "PermitSingle",
+    };
+};

package/lib/esm/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/esm/signatures/quote.js

@@ -0,0 +1,36 @@
+import { getChainAddresses } from "../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" },
+    ],
+};
+export const getQuoteTypedData = (chainId, quote) => {
+    return {
+        domain: {
+            chainId,
+            verifyingContract: getChainAddresses(chainId).iris,
+        },
+        types: quoteTypes,
+        message: quote,
+        primaryType: "Quote",
+    };
+};

package/lib/esm/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/esm/types.js

@@ -0,0 +1,3 @@
+export const isMarketId = (value) => {
+    return typeof value === "string" && /^0x[0-9A-Fa-f]{64}$/.test(value);
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@iris-credit/core-sdk",
+  "version": "0.0.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iris-credit/iris-sdks.git",
+    "directory": "packages/core-sdk"
+  },
+  "files": [
+    "lib"
+  ],
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/esm/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "devDependencies": {
+    "viem": "^2.41.2"
+  },
+  "peerDependencies": {
+    "viem": "^2",
+    "@iris-credit/iris-ts": "^0.0.0"
+  },
+  "scripts": {
+    "prepublish": "$npm_execpath build",
+    "build": "tsgo --noEmit && $npm_execpath build:cjs && $npm_execpath build:esm",
+    "build:cjs": "tsgo --build tsconfig.build.cjs.json && echo '{\"type\":\"commonjs\"}' > lib/cjs/package.json",
+    "build:esm": "tsgo --build tsconfig.build.esm.json && echo '{\"type\":\"module\"}' > lib/esm/package.json"
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./chain.js";
+export * from "./constants.js";
+export * from "./addresses.js";
+export * from "./signatures/index.js";
+export * from "./math/index.js";
+export * from "./abis/index.js";