@kleros/kleros-sdk 2.1.6 → 2.1.8

package/lib/src/consts.d.ts

@@ -0,0 +1 @@
+export declare const MAX_BYTE_SIZE = 1000000;

package/lib/src/consts.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_BYTE_SIZE = void 0;
+exports.MAX_BYTE_SIZE = 1000000;

package/lib/src/dataMappings/actions/callAction.d.ts

@@ -0,0 +1,2 @@
+import { AbiCallMapping } from "../utils/actionTypes";
+export declare const callAction: (mapping: AbiCallMapping) => Promise<Record<string, any>>;

package/lib/src/dataMappings/actions/callAction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAction = void 0;
+const viem_1 = require("viem");
+const createResultObject_1 = require("../utils/createResultObject");
+const sdk_1 = require("../../sdk");
+const errors_1 = require("../../errors");
+const callAction = async (mapping) => {
+    const publicClient = (0, sdk_1.getPublicClient)();
+    if (!publicClient) {
+        throw new errors_1.SdkNotConfiguredError();
+    }
+    const { abi: source, address, functionName, args, seek, populate } = mapping;
+    const parsedAbi = typeof source === "string" ? (0, viem_1.parseAbiItem)(source) : source;
+    const data = await publicClient.readContract({
+        address,
+        abi: [parsedAbi],
+        functionName,
+        args,
+    });
+    return (0, createResultObject_1.createResultObject)(data, seek, populate);
+};
+exports.callAction = callAction;

package/lib/src/dataMappings/actions/eventAction.d.ts

@@ -0,0 +1,2 @@
+import { AbiEventMapping } from "../utils/actionTypes";
+export declare const eventAction: (mapping: AbiEventMapping) => Promise<Record<string, any>>;

package/lib/src/dataMappings/actions/eventAction.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventAction = void 0;
+const viem_1 = require("viem");
+const createResultObject_1 = require("../utils/createResultObject");
+const sdk_1 = require("../../sdk");
+const errors_1 = require("../../errors");
+const eventAction = async (mapping) => {
+    const publicClient = (0, sdk_1.getPublicClient)();
+    if (!publicClient) {
+        throw new errors_1.SdkNotConfiguredError();
+    }
+    const { abi: source, address, eventFilter, seek, populate } = mapping;
+    const parsedAbi = (0, viem_1.parseAbiItem)(source);
+    const filter = await publicClient.createEventFilter({
+        address,
+        event: parsedAbi,
+        args: eventFilter.args,
+        fromBlock: eventFilter.fromBlock,
+        toBlock: eventFilter.toBlock,
+    });
+    const contractEvent = await publicClient.getFilterLogs({ filter });
+    const eventData = contractEvent[0].args;
+    return (0, createResultObject_1.createResultObject)(eventData, seek, populate);
+};
+exports.eventAction = eventAction;

package/lib/src/dataMappings/actions/fetchIpfsJsonAction.d.ts

@@ -0,0 +1,2 @@
+import { FetchIpfsJsonMapping } from "../utils/actionTypes";
+export declare const fetchIpfsJsonAction: (mapping: FetchIpfsJsonMapping) => Promise<Record<string, any>>;

package/lib/src/dataMappings/actions/fetchIpfsJsonAction.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchIpfsJsonAction = void 0;
+const consts_1 = require("../../consts");
+const errors_1 = require("../../errors");
+const createResultObject_1 = require("../utils/createResultObject");
+const fetchIpfsJsonAction = async (mapping) => {
+    const { ipfsUri, seek, populate } = mapping;
+    let httpUri;
+    if (ipfsUri.startsWith("/ipfs/")) {
+        httpUri = `https://ipfs.io${ipfsUri}`;
+    }
+    else if (ipfsUri.startsWith("ipfs://")) {
+        httpUri = ipfsUri.replace("ipfs://", "https://ipfs.io/ipfs/");
+    }
+    else if (!ipfsUri.startsWith("http")) {
+        httpUri = `https://ipfs.io/ipfs/${ipfsUri}`;
+    }
+    else {
+        throw new errors_1.RequestError("Invalid IPFS URI format", httpUri);
+    }
+    const response = await fetch(httpUri, { method: "GET" });
+    if (!response.ok) {
+        throw new errors_1.RequestError("Failed to fetch data from IPFS", httpUri);
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && parseInt(contentLength) > consts_1.MAX_BYTE_SIZE) {
+        throw new errors_1.RequestError("Response size is too large", httpUri);
+    }
+    const contentType = response.headers.get("content-type");
+    if (!contentType || !contentType.includes("application/json")) {
+        throw new errors_1.RequestError("Fetched data is not JSON", httpUri);
+    }
+    const data = (await response.json());
+    return (0, createResultObject_1.createResultObject)(data, seek, populate);
+};
+exports.fetchIpfsJsonAction = fetchIpfsJsonAction;

package/lib/src/dataMappings/actions/jsonAction.d.ts

@@ -0,0 +1,2 @@
+import { JsonMapping } from "../utils/actionTypes";
+export declare const jsonAction: (mapping: JsonMapping) => Record<string, any>;

package/lib/src/dataMappings/actions/jsonAction.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonAction = void 0;
+const createResultObject_1 = require("../utils/createResultObject");
+const jsonAction = (mapping) => {
+    const { value, seek, populate } = mapping;
+    const parsedValue = typeof value === "string" ? JSON.parse(value) : value;
+    return (0, createResultObject_1.createResultObject)(parsedValue, seek, populate);
+};
+exports.jsonAction = jsonAction;

package/lib/src/dataMappings/actions/subgraphAction.d.ts

@@ -0,0 +1,2 @@
+import { SubgraphMapping } from "../utils/actionTypes";
+export declare const subgraphAction: (mapping: SubgraphMapping) => Promise<Record<string, any>>;

package/lib/src/dataMappings/actions/subgraphAction.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subgraphAction = void 0;
+const createResultObject_1 = require("../utils/createResultObject");
+const subgraphAction = async (mapping) => {
+    const { endpoint, query, variables, seek, populate } = mapping;
+    const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        },
+        body: JSON.stringify({ query, variables }),
+    });
+    const { data } = (await response.json());
+    return (0, createResultObject_1.createResultObject)(data, seek, populate);
+};
+exports.subgraphAction = subgraphAction;

package/lib/src/dataMappings/executeActions.d.ts

@@ -0,0 +1,5 @@
+import { ActionMapping } from "./utils/actionTypes";
+type ActionResult = Record<string, unknown> | null | undefined;
+export declare const executeAction: (mapping: ActionMapping, context?: Record<string, unknown>) => Promise<ActionResult>;
+export declare const executeActions: (mappings: ActionMapping[], initialContext?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export {};

package/lib/src/dataMappings/executeActions.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeActions = exports.executeAction = void 0;
+const errors_1 = require("../errors");
+const callAction_1 = require("./actions/callAction");
+const eventAction_1 = require("./actions/eventAction");
+const fetchIpfsJsonAction_1 = require("./actions/fetchIpfsJsonAction");
+const jsonAction_1 = require("./actions/jsonAction");
+const subgraphAction_1 = require("./actions/subgraphAction");
+const retrieveRealityData_1 = require("./retrieveRealityData");
+const actionTypeValidators_1 = require("./utils/actionTypeValidators");
+const replacePlaceholdersWithValues_1 = require("./utils/replacePlaceholdersWithValues");
+const executeAction = async (mapping, context = {}) => {
+    mapping = (0, replacePlaceholdersWithValues_1.replacePlaceholdersWithValues)(mapping, context);
+    switch (mapping.type) {
+        case "graphql":
+            return await (0, subgraphAction_1.subgraphAction)((0, actionTypeValidators_1.validateSubgraphMapping)(mapping));
+        case "json":
+            return (0, jsonAction_1.jsonAction)((0, actionTypeValidators_1.validateJsonMapping)(mapping));
+        case "abi/call":
+            return await (0, callAction_1.callAction)((0, actionTypeValidators_1.validateAbiCallMapping)(mapping));
+        case "abi/event":
+            return await (0, eventAction_1.eventAction)((0, actionTypeValidators_1.validateAbiEventMapping)(mapping));
+        case "fetch/ipfs/json":
+            return await (0, fetchIpfsJsonAction_1.fetchIpfsJsonAction)((0, actionTypeValidators_1.validateFetchIpfsJsonMapping)(mapping));
+        case "reality":
+            mapping = (0, actionTypeValidators_1.validateRealityMapping)(mapping);
+            return await (0, retrieveRealityData_1.retrieveRealityData)(mapping.realityQuestionID, context.arbitrableAddress);
+        default:
+            throw new errors_1.UnsupportedActionError(`Unsupported action type: ${JSON.stringify(mapping)}`);
+    }
+};
+exports.executeAction = executeAction;
+const executeActions = async (mappings, initialContext = {}) => {
+    const context = { ...initialContext };
+    for (const mapping of mappings) {
+        const actionResult = await (0, exports.executeAction)(mapping, context);
+        if (actionResult) {
+            Object.keys(actionResult).forEach((key) => {
+                context[key] = actionResult[key];
+            });
+        }
+    }
+    return context;
+};
+exports.executeActions = executeActions;

package/lib/src/dataMappings/index.d.ts

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

package/lib/src/dataMappings/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("./executeActions"), exports);

package/lib/src/dataMappings/retrieveRealityData.d.ts

@@ -0,0 +1,15 @@
+export type RealityAnswer = {
+    title: string;
+    description: string;
+    id: string;
+    reserved: boolean;
+    last?: boolean;
+};
+export declare const retrieveRealityData: (realityQuestionID: string, arbitrable?: `0x${string}`) => Promise<{
+    question: unknown;
+    type: any;
+    realityAddress: unknown;
+    questionId: unknown;
+    realityUser: unknown;
+    answers: RealityAnswer[];
+}>;

package/lib/src/dataMappings/retrieveRealityData.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveRealityData = void 0;
+const errors_1 = require("../errors");
+const executeActions_1 = require("./executeActions");
+const retrieveRealityData = async (realityQuestionID, arbitrable) => {
+    if (!arbitrable) {
+        throw new errors_1.InvalidContextError("No arbitrable address provided");
+    }
+    const questionMapping = {
+        type: "abi/event",
+        abi: "event LogNewQuestion(bytes32 indexed question_id, address indexed user, uint256 template_id, string question, bytes32 indexed content_hash, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 created)",
+        address: arbitrable,
+        eventFilter: {
+            args: [realityQuestionID],
+            fromBlock: "earliest",
+            toBlock: "latest",
+        },
+        seek: [
+            "question_id",
+            "user",
+            "template_id",
+            "question",
+            "content_hash",
+            "arbitrator",
+            "timeout",
+            "opening_ts",
+            "nonce",
+            "created",
+        ],
+        populate: [
+            "realityQuestionID",
+            "realityUser",
+            "realityTemplateID",
+            "realityQuestion",
+            "contentHash",
+            "arbitrator",
+            "timeout",
+            "openingTs",
+            "nonce",
+            "created",
+        ],
+    };
+    const questionData = await (0, executeActions_1.executeAction)(questionMapping);
+    console.log("questionData", questionData);
+    const templateMapping = {
+        type: "abi/event",
+        abi: "event LogNewTemplate(uint256 indexed template_id, address indexed user, string question_text)",
+        address: arbitrable,
+        eventFilter: {
+            args: [0],
+            fromBlock: "earliest",
+            toBlock: "latest",
+        },
+        seek: ["template_id", "question_text"],
+        populate: ["templateID", "questionText"],
+    };
+    const templateData = await (0, executeActions_1.executeAction)(templateMapping);
+    console.log("templateData", templateData);
+    if (!templateData) {
+        throw new errors_1.NotFoundError("Template Data", "Failed to retrieve template data");
+    }
+    if (!questionData) {
+        throw new errors_1.NotFoundError("Question Data", "Failed to retrieve question data");
+    }
+    const rc_question = require("@reality.eth/reality-eth-lib/formatters/question.js");
+    const populatedTemplate = rc_question.populatedJSONForTemplate(templateData.questionText, questionData.realityQuestion);
+    console.log("populatedTemplate", populatedTemplate);
+    let answers = [];
+    if (populatedTemplate.type === "bool") {
+        answers = [
+            {
+                title: "Yes",
+                description: "",
+                id: "0x01",
+                reserved: false,
+            },
+            {
+                title: "No",
+                description: "",
+                id: "0x02",
+                reserved: false,
+            },
+        ];
+    }
+    answers.push({
+        id: "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+        title: "Answered Too Soon",
+        description: "",
+        reserved: true,
+    });
+    for (let i = 0; i < answers.length; i++) {
+        answers[i].last = i === answers.length - 1;
+    }
+    return {
+        question: questionData.realityQuestion,
+        type: populatedTemplate.type,
+        realityAddress: questionData.arbitrator,
+        questionId: questionData.realityQuestionID,
+        realityUser: questionData.realityUser,
+        answers,
+    };
+};
+exports.retrieveRealityData = retrieveRealityData;

package/lib/src/dataMappings/utils/actionTypeValidators.d.ts

@@ -0,0 +1,7 @@
+import { SubgraphMapping, AbiEventMapping, AbiCallMapping, JsonMapping, ActionMapping, FetchIpfsJsonMapping } from "./actionTypes";
+export declare const validateSubgraphMapping: (mapping: ActionMapping) => SubgraphMapping;
+export declare const validateAbiEventMapping: (mapping: ActionMapping) => AbiEventMapping;
+export declare const validateAbiCallMapping: (mapping: ActionMapping) => AbiCallMapping;
+export declare const validateJsonMapping: (mapping: ActionMapping) => JsonMapping;
+export declare const validateFetchIpfsJsonMapping: (mapping: ActionMapping) => FetchIpfsJsonMapping;
+export declare const validateRealityMapping: (mapping: ActionMapping) => import("./actionTypes").RealityMapping;

package/lib/src/dataMappings/utils/actionTypeValidators.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRealityMapping = exports.validateFetchIpfsJsonMapping = exports.validateJsonMapping = exports.validateAbiCallMapping = exports.validateAbiEventMapping = exports.validateSubgraphMapping = void 0;
+const errors_1 = require("../../errors");
+const validateSubgraphMapping = (mapping) => {
+    return validateMapping(mapping, ["endpoint"]);
+};
+exports.validateSubgraphMapping = validateSubgraphMapping;
+const validateAbiEventMapping = (mapping) => {
+    return validateMapping(mapping, ["abi", "eventFilter"]);
+};
+exports.validateAbiEventMapping = validateAbiEventMapping;
+const validateAbiCallMapping = (mapping) => {
+    return validateMapping(mapping, ["abi", "functionName"]);
+};
+exports.validateAbiCallMapping = validateAbiCallMapping;
+const validateJsonMapping = (mapping) => {
+    return validateMapping(mapping, ["value"]);
+};
+exports.validateJsonMapping = validateJsonMapping;
+const validateFetchIpfsJsonMapping = (mapping) => {
+    return validateMapping(mapping, ["ipfsUri"]);
+};
+exports.validateFetchIpfsJsonMapping = validateFetchIpfsJsonMapping;
+const validateRealityMapping = (mapping) => {
+    if (mapping.type !== "reality" || typeof mapping.realityQuestionID !== "string") {
+        throw new errors_1.InvalidMappingError("Expected field 'realityQuestionID' to be a string.");
+    }
+    return mapping;
+};
+exports.validateRealityMapping = validateRealityMapping;
+const validateMapping = (mapping, requiredFields) => {
+    for (const field of requiredFields) {
+        if (mapping[field] === undefined) {
+            throw new errors_1.InvalidMappingError(`${field.toString()} is required for ${mapping.type}`);
+        }
+    }
+    return mapping;
+};

package/lib/src/dataMappings/utils/actionTypes.d.ts

@@ -0,0 +1,40 @@
+import { type Address, type BlockNumber, type BlockTag } from "viem";
+type MappingType = "graphql" | "abi/call" | "abi/event" | "json" | "fetch/ipfs/json" | "reality";
+type AbstractMapping<T extends MappingType> = {
+    type: T;
+    seek: string[];
+    populate: string[];
+};
+export type JsonMapping = AbstractMapping<"json"> & {
+    value: object;
+};
+export type SubgraphMapping = AbstractMapping<"graphql"> & {
+    endpoint: string;
+    query: string;
+    variables: {
+        [key: string]: unknown;
+    };
+};
+export type AbiCallMapping = AbstractMapping<"abi/call"> & {
+    abi: string;
+    address: Address;
+    functionName: string;
+    args: any[];
+};
+export type AbiEventMapping = AbstractMapping<"abi/event"> & {
+    abi: string;
+    address: Address;
+    eventFilter: {
+        fromBlock: BlockNumber | BlockTag;
+        toBlock: BlockNumber | BlockTag;
+        args: any;
+    };
+};
+export type FetchIpfsJsonMapping = AbstractMapping<"fetch/ipfs/json"> & {
+    ipfsUri: string;
+};
+export type RealityMapping = AbstractMapping<"reality"> & {
+    realityQuestionID: string;
+};
+export type ActionMapping = SubgraphMapping | AbiEventMapping | AbiCallMapping | JsonMapping | FetchIpfsJsonMapping | RealityMapping;
+export {};

package/lib/src/dataMappings/utils/actionTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/dataMappings/utils/createResultObject.d.ts

@@ -0,0 +1 @@
+export declare const createResultObject: (sourceData: Record<string, any>, seek: string[], populate: string[]) => Record<string, any>;

package/lib/src/dataMappings/utils/createResultObject.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResultObject = void 0;
+const createResultObject = (sourceData, seek, populate) => {
+    const result = {};
+    const getNestedValue = (obj, path) => {
+        return path.split(".").reduce((acc, part) => {
+            if (acc && part.includes("[")) {
+                const [key, index] = part.replace(/\]/g, "").split("[");
+                return acc[key]?.[index];
+            }
+            return acc ? acc[part] : undefined;
+        }, obj);
+    };
+    seek.forEach((key, idx) => {
+        const foundValue = getNestedValue(sourceData, key);
+        if (foundValue !== undefined) {
+            result[populate[idx]] = foundValue;
+        }
+    });
+    return result;
+};
+exports.createResultObject = createResultObject;

package/lib/src/dataMappings/utils/disputeDetailsSchema.d.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+export declare const isHexAddress: (str: string) => boolean;
+export declare const isHexId: (str: string) => boolean;
+export declare const isMultiaddr: (str: string) => boolean;
+export declare const ethAddressSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const ensNameSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const ethAddressOrEnsNameSchema: z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodEffects<z.ZodString, string, string>]>;
+export declare enum QuestionType {
+    Bool = "bool",
+    Datetime = "datetime",
+    MultipleSelect = "multiple-select",
+    SingleSelect = "single-select",
+    Uint = "uint"
+}
+export declare const QuestionTypeSchema: z.ZodNativeEnum<typeof QuestionType>;
+export declare const AnswerSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodString;
+    reserved: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    title: string;
+    id?: string | undefined;
+    reserved?: boolean | undefined;
+}, {
+    description: string;
+    title: string;
+    id?: string | undefined;
+    reserved?: boolean | undefined;
+}>;
+export declare const AttachmentSchema: z.ZodObject<{
+    label: z.ZodString;
+    uri: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    uri: string;
+}, {
+    label: string;
+    uri: string;
+}>;
+export declare const AliasSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodEffects<z.ZodString, string, string>]>>;
+declare const DisputeDetailsSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    question: z.ZodString;
+    answers: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        description: z.ZodString;
+        reserved: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        title: string;
+        id?: string | undefined;
+        reserved?: boolean | undefined;
+    }, {
+        description: string;
+        title: string;
+        id?: string | undefined;
+        reserved?: boolean | undefined;
+    }>, "many">;
+    policyURI: z.ZodEffects<z.ZodString, string, string>;
+    attachment: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        uri: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        uri: string;
+    }, {
+        label: string;
+        uri: string;
+    }>>;
+    frontendUrl: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    arbitratorChainID: z.ZodString;
+    arbitratorAddress: z.ZodEffects<z.ZodString, string, string>;
+    category: z.ZodOptional<z.ZodString>;
+    lang: z.ZodOptional<z.ZodString>;
+    specification: z.ZodOptional<z.ZodString>;
+    aliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodEffects<z.ZodString, string, string>]>>>;
+    version: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    question: string;
+    answers: {
+        description: string;
+        title: string;
+        id?: string | undefined;
+        reserved?: boolean | undefined;
+    }[];
+    title: string;
+    policyURI: string;
+    arbitratorChainID: string;
+    arbitratorAddress: string;
+    version: string;
+    attachment?: {
+        label: string;
+        uri: string;
+    } | undefined;
+    frontendUrl?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    category?: string | undefined;
+    lang?: string | undefined;
+    specification?: string | undefined;
+    aliases?: Record<string, string> | undefined;
+}, {
+    description: string;
+    question: string;
+    answers: {
+        description: string;
+        title: string;
+        id?: string | undefined;
+        reserved?: boolean | undefined;
+    }[];
+    title: string;
+    policyURI: string;
+    arbitratorChainID: string;
+    arbitratorAddress: string;
+    version: string;
+    attachment?: {
+        label: string;
+        uri: string;
+    } | undefined;
+    frontendUrl?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    category?: string | undefined;
+    lang?: string | undefined;
+    specification?: string | undefined;
+    aliases?: Record<string, string> | undefined;
+}>;
+export default DisputeDetailsSchema;

package/lib/src/dataMappings/utils/disputeDetailsSchema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasSchema = exports.AttachmentSchema = exports.AnswerSchema = exports.QuestionTypeSchema = exports.QuestionType = exports.ethAddressOrEnsNameSchema = exports.ensNameSchema = exports.ethAddressSchema = exports.isMultiaddr = exports.isHexId = exports.isHexAddress = void 0;
+const zod_1 = require("zod");
+const viem_1 = require("viem");
+const ens_1 = require("viem/ens");
+const isHexAddress = (str) => /^0x[a-fA-F0-9]{40}$/.test(str);
+exports.isHexAddress = isHexAddress;
+const isHexId = (str) => /^0x[a-fA-F0-9]{1,64}$/.test(str);
+exports.isHexId = isHexId;
+const isMultiaddr = (str) => /^\/(?:ip4|ip6|dns4|dns6|dnsaddr|tcp|udp|utp|tls|ws|wss|p2p-circuit|p2p-webrtc-star|p2p-webrtc-direct|p2p-websocket-star|onion|ipfs)(\/[^\s\/]+)+$|^ipfs:\/\/[a-zA-Z0-9]+\/[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)?$/.test(str);
+exports.isMultiaddr = isMultiaddr;
+exports.ethAddressSchema = zod_1.z.string().refine((value) => (0, viem_1.isAddress)(value, { strict: false }), {
+    message: "Provided address is invalid.",
+});
+exports.ensNameSchema = zod_1.z
+    .string()
+    .refine((value) => typeof (0, ens_1.normalize)(value) === "string" && value.endsWith(".eth"), {
+    message: "Provided ENS name is invalid.",
+});
+exports.ethAddressOrEnsNameSchema = zod_1.z.union([exports.ethAddressSchema, exports.ensNameSchema], {
+    errorMap: () => ({ message: "Provided address or ENS name is invalid." }),
+});
+var QuestionType;
+(function (QuestionType) {
+    QuestionType["Bool"] = "bool";
+    QuestionType["Datetime"] = "datetime";
+    QuestionType["MultipleSelect"] = "multiple-select";
+    QuestionType["SingleSelect"] = "single-select";
+    QuestionType["Uint"] = "uint";
+})(QuestionType || (exports.QuestionType = QuestionType = {}));
+exports.QuestionTypeSchema = zod_1.z.nativeEnum(QuestionType);
+exports.AnswerSchema = zod_1.z.object({
+    id: zod_1.z
+        .string()
+        .regex(/^0x[0-9a-fA-F]+$/)
+        .optional(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    reserved: zod_1.z.boolean().optional(),
+});
+exports.AttachmentSchema = zod_1.z.object({
+    label: zod_1.z.string(),
+    uri: zod_1.z.string(),
+});
+exports.AliasSchema = zod_1.z.record(exports.ethAddressOrEnsNameSchema);
+const MetadataSchema = zod_1.z.record(zod_1.z.unknown());
+const DisputeDetailsSchema = zod_1.z.object({
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    question: zod_1.z.string(),
+    answers: zod_1.z.array(exports.AnswerSchema),
+    policyURI: zod_1.z.string().refine((value) => (0, exports.isMultiaddr)(value), {
+        message: "Provided policy URI is not a valid multiaddr.",
+    }),
+    attachment: exports.AttachmentSchema.optional(),
+    frontendUrl: zod_1.z.string().optional(),
+    metadata: MetadataSchema.optional(),
+    arbitratorChainID: zod_1.z.string(),
+    arbitratorAddress: exports.ethAddressSchema,
+    category: zod_1.z.string().optional(),
+    lang: zod_1.z.string().optional(),
+    specification: zod_1.z.string().optional(),
+    aliases: exports.AliasSchema.optional(),
+    version: zod_1.z.string(),
+});
+exports.default = DisputeDetailsSchema;

package/lib/src/dataMappings/utils/disputeDetailsTypes.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import DisputeDetailsSchema, { AliasSchema, AnswerSchema, AttachmentSchema } from "./disputeDetailsSchema";
+export { QuestionType } from "./disputeDetailsSchema";
+export type DisputeDetails = z.infer<typeof DisputeDetailsSchema>;
+export type Answer = z.infer<typeof AnswerSchema>;
+export type Alias = z.infer<typeof AliasSchema>;
+export type Attachment = z.infer<typeof AttachmentSchema>;

package/lib/src/dataMappings/utils/disputeDetailsTypes.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionType = void 0;
+var disputeDetailsSchema_1 = require("./disputeDetailsSchema");
+Object.defineProperty(exports, "QuestionType", { enumerable: true, get: function () { return disputeDetailsSchema_1.QuestionType; } });

package/lib/src/dataMappings/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./populateTemplate";
+export * from "./retrieveVariables";
+export * from "./disputeDetailsTypes";

package/lib/src/dataMappings/utils/index.js

@@ -0,0 +1,19 @@
+"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("./populateTemplate"), exports);
+__exportStar(require("./retrieveVariables"), exports);
+__exportStar(require("./disputeDetailsTypes"), exports);

package/lib/src/dataMappings/utils/populateTemplate.d.ts

@@ -0,0 +1,2 @@
+import { DisputeDetails } from "./disputeDetailsTypes";
+export declare const populateTemplate: (mustacheTemplate: string, data: any) => DisputeDetails;

package/lib/src/dataMappings/utils/populateTemplate.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateTemplate = void 0;
+const mustache_1 = __importDefault(require("mustache"));
+const disputeDetailsSchema_1 = __importDefault(require("./disputeDetailsSchema"));
+const errors_1 = require("../../errors");
+const populateTemplate = (mustacheTemplate, data) => {
+    const render = mustache_1.default.render(mustacheTemplate, data);
+    const dispute = JSON.parse(render);
+    const validation = disputeDetailsSchema_1.default.safeParse(dispute);
+    if (!validation.success) {
+        console.error("Validation errors:", validation.error.errors, "\n\nDispute details:", `${JSON.stringify(dispute)}`);
+        throw new errors_1.InvalidFormatError("Invalid dispute details format");
+    }
+    console.log(dispute);
+    return dispute;
+};
+exports.populateTemplate = populateTemplate;

package/lib/src/dataMappings/utils/replacePlaceholdersWithValues.d.ts

@@ -0,0 +1,2 @@
+import { ActionMapping } from "./actionTypes";
+export declare function replacePlaceholdersWithValues(mapping: ActionMapping, context: Record<string, unknown>): ActionMapping | ActionMapping[];

package/lib/src/dataMappings/utils/replacePlaceholdersWithValues.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replacePlaceholdersWithValues = void 0;
+const mustache_1 = __importDefault(require("mustache"));
+const retrieveVariables_1 = __importDefault(require("./retrieveVariables"));
+const errors_1 = require("../../errors");
+function replacePlaceholdersWithValues(mapping, context) {
+    function replace(obj) {
+        if (typeof obj === "string") {
+            validateContext(obj, context);
+            return mustache_1.default.render(obj, context);
+        }
+        else if (Array.isArray(obj)) {
+            return obj.map(replace);
+        }
+        else if (typeof obj === "object" && obj !== null) {
+            return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, replace(value)]));
+        }
+        else {
+            return obj;
+        }
+    }
+    return replace(mapping);
+}
+exports.replacePlaceholdersWithValues = replacePlaceholdersWithValues;
+const validateContext = (template, context) => {
+    const variables = (0, retrieveVariables_1.default)(template);
+    variables.forEach((variable) => {
+        if (!context[variable])
+            throw new errors_1.InvalidContextError(`Expected key "${variable}" to be provided in context.`);
+    });
+    return true;
+};

package/lib/src/dataMappings/utils/retrieveVariables.d.ts

@@ -0,0 +1,2 @@
+declare const retrieveVariables: (template: string) => string[];
+export default retrieveVariables;

package/lib/src/dataMappings/utils/retrieveVariables.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mustache_1 = __importDefault(require("mustache"));
+const retrieveVariables = (template) => mustache_1.default
+    .parse(template)
+    .filter(function (v) {
+    return v[0] === "name" || v[0] === "&";
+})
+    .map(function (v) {
+    return v[1];
+});
+exports.default = retrieveVariables;

package/lib/src/errors/index.d.ts

@@ -0,0 +1,26 @@
+export declare class CustomError extends Error {
+    constructor(name: string, message: string);
+}
+export declare class InvalidContextError extends CustomError {
+    constructor(message: string);
+}
+export declare class InvalidMappingError extends CustomError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends CustomError {
+    resourceName: string;
+    constructor(resourceName: string, message: string);
+}
+export declare class RequestError extends CustomError {
+    endpoint: string | undefined;
+    constructor(message: string, endpoint?: string);
+}
+export declare class UnsupportedActionError extends CustomError {
+    constructor(message: string);
+}
+export declare class InvalidFormatError extends CustomError {
+    constructor(message: string);
+}
+export declare class SdkNotConfiguredError extends CustomError {
+    constructor();
+}

package/lib/src/errors/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkNotConfiguredError = exports.InvalidFormatError = exports.UnsupportedActionError = exports.RequestError = exports.NotFoundError = exports.InvalidMappingError = exports.InvalidContextError = exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(name, message) {
+        super(message);
+        this.name = name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+exports.CustomError = CustomError;
+class InvalidContextError extends CustomError {
+    constructor(message) {
+        super("InvalidContextError", message);
+    }
+}
+exports.InvalidContextError = InvalidContextError;
+class InvalidMappingError extends CustomError {
+    constructor(message) {
+        super("InvalidMappingError", message);
+    }
+}
+exports.InvalidMappingError = InvalidMappingError;
+class NotFoundError extends CustomError {
+    resourceName;
+    constructor(resourceName, message) {
+        super("NotFoundError", message);
+        this.resourceName = resourceName;
+    }
+}
+exports.NotFoundError = NotFoundError;
+class RequestError extends CustomError {
+    endpoint;
+    constructor(message, endpoint) {
+        super("RequestError", message);
+        this.endpoint = endpoint;
+    }
+}
+exports.RequestError = RequestError;
+class UnsupportedActionError extends CustomError {
+    constructor(message) {
+        super("UnsupportedActionError", message);
+    }
+}
+exports.UnsupportedActionError = UnsupportedActionError;
+class InvalidFormatError extends CustomError {
+    constructor(message) {
+        super("InvalidFormatError", message);
+    }
+}
+exports.InvalidFormatError = InvalidFormatError;
+class SdkNotConfiguredError extends CustomError {
+    constructor() {
+        super("SdkNotConfiguredError", "SDK not configured. Please call `configureSDK` before using.");
+    }
+}
+exports.SdkNotConfiguredError = SdkNotConfiguredError;

package/lib/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./sdk";
+export * from "./types";
+export * from "./utils";
+export * from "./dataMappings";
+export * from "./dataMappings/utils";

package/lib/src/index.js

@@ -0,0 +1,21 @@
+"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("./sdk"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./dataMappings"), exports);
+__exportStar(require("./dataMappings/utils"), exports);

package/lib/src/requests/fetchDisputeDetails.d.ts

@@ -0,0 +1,12 @@
+type DisputeDetailsQueryResponse = {
+    dispute: {
+        arbitrated: {
+            id: string;
+        };
+        arbitrableChainId: number;
+        externalDisputeId: number;
+        templateId: number;
+    };
+};
+declare const fetchDisputeDetails: (endpoint: string, id: bigint) => Promise<DisputeDetailsQueryResponse | undefined>;
+export default fetchDisputeDetails;

package/lib/src/requests/fetchDisputeDetails.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const core_1 = require("@urql/core");
+const gqlClient_1 = __importDefault(require("./gqlClient"));
+const query = (0, core_1.gql) `
+  query DisputeDetails($id: ID!) {
+    dispute(id: $id) {
+      arbitrated {
+        id
+      }
+      arbitrableChainId
+      externalDisputeId
+      templateId
+    }
+  }
+`;
+const fetchDisputeDetails = async (endpoint, id) => {
+    const variables = { id: id.toString() };
+    try {
+        const client = (0, gqlClient_1.default)(endpoint);
+        return client
+            .query(query, variables)
+            .toPromise()
+            .then((res) => {
+            if (res?.error) {
+                throw res.error;
+            }
+            return res?.data;
+        });
+    }
+    catch (error) {
+        if (error instanceof core_1.CombinedError) {
+            throw error;
+        }
+        else if (error instanceof Error) {
+            throw new errors_1.RequestError(`Error querying Dispute Details: ${error.message}`, endpoint);
+        }
+        throw new errors_1.RequestError("An unknown error occurred while querying Dispute Details", endpoint);
+    }
+};
+exports.default = fetchDisputeDetails;

package/lib/src/requests/fetchDisputeTemplateFromId.d.ts

@@ -0,0 +1,8 @@
+type DisputeTemplateQueryResponse = {
+    disputeTemplate: {
+        templateData: string;
+        templateDataMappings: string;
+    };
+};
+declare const fetchDisputeTemplateFromId: (endpoint: string, id: number) => Promise<DisputeTemplateQueryResponse | undefined>;
+export default fetchDisputeTemplateFromId;

package/lib/src/requests/fetchDisputeTemplateFromId.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@urql/core");
+const errors_1 = require("../errors");
+const gqlClient_1 = __importDefault(require("./gqlClient"));
+const query = (0, core_1.gql) `
+  query DisputeTemplate($id: ID!) {
+    disputeTemplate(id: $id) {
+      templateData
+      templateDataMappings
+    }
+  }
+`;
+const fetchDisputeTemplateFromId = async (endpoint, id) => {
+    const variables = { id: id.toString() };
+    try {
+        const client = (0, gqlClient_1.default)(endpoint);
+        return client
+            .query(query, variables)
+            .toPromise()
+            .then((res) => {
+            if (res?.error) {
+                throw res.error;
+            }
+            return res?.data;
+        });
+    }
+    catch (error) {
+        if (error instanceof core_1.CombinedError) {
+            throw error;
+        }
+        else if (error instanceof Error) {
+            throw new errors_1.RequestError(`Error querying Dispute Template: ${error.message}`, endpoint);
+        }
+        throw new errors_1.RequestError("An unknown error occurred while querying Dispute Template", endpoint);
+    }
+};
+exports.default = fetchDisputeTemplateFromId;

package/lib/src/requests/gqlClient.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "@urql/core";
+declare const getClient: (endpoint: string) => Client;
+export default getClient;

package/lib/src/requests/gqlClient.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@urql/core");
+const clients = new Map();
+const getClient = (endpoint) => {
+    let client = clients.get(endpoint);
+    if (!client) {
+        client = new core_1.Client({
+            url: endpoint,
+            exchanges: [core_1.cacheExchange, core_1.fetchExchange],
+        });
+        clients.set(endpoint, client);
+    }
+    return client;
+};
+exports.default = getClient;

package/lib/src/sdk.d.ts

@@ -0,0 +1,4 @@
+import { type PublicClient } from "viem";
+import { SdkConfig } from "./types";
+export declare const configureSDK: (config: SdkConfig) => void;
+export declare const getPublicClient: () => PublicClient | undefined;

package/lib/src/sdk.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicClient = exports.configureSDK = void 0;
+const viem_1 = require("viem");
+const errors_1 = require("./errors");
+let publicClient;
+const configureSDK = (config) => {
+    if (config.client) {
+        publicClient = (0, viem_1.createPublicClient)(config.client);
+    }
+};
+exports.configureSDK = configureSDK;
+const getPublicClient = () => {
+    if (!publicClient) {
+        throw new errors_1.SdkNotConfiguredError();
+    }
+    return publicClient;
+};
+exports.getPublicClient = getPublicClient;

package/lib/src/types/index.d.ts

@@ -0,0 +1,15 @@
+import { PublicClientConfig } from "viem";
+export type SdkConfig = {
+    client: PublicClientConfig;
+};
+type GetDisputeParametersOptions = {
+    sdkConfig?: SdkConfig;
+    additionalContext?: Record<string, any>;
+};
+export type GetDisputeParameters = {
+    disputeId: bigint;
+    coreSubgraph: string;
+    dtrSubgraph: string;
+    options?: GetDisputeParametersOptions;
+};
+export {};

package/lib/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/utils/getDispute.d.ts

@@ -0,0 +1,3 @@
+import { DisputeDetails } from "../dataMappings/utils";
+import { GetDisputeParameters } from "../types";
+export declare const getDispute: (disputeParameters: GetDisputeParameters) => Promise<DisputeDetails | undefined>;

package/lib/src/utils/getDispute.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDispute = void 0;
+const dataMappings_1 = require("../dataMappings");
+const utils_1 = require("../dataMappings/utils");
+const errors_1 = require("../errors");
+const fetchDisputeDetails_1 = __importDefault(require("../requests/fetchDisputeDetails"));
+const fetchDisputeTemplateFromId_1 = __importDefault(require("../requests/fetchDisputeTemplateFromId"));
+const sdk_1 = require("../sdk");
+const getDispute = async (disputeParameters) => {
+    if (disputeParameters.options?.sdkConfig) {
+        (0, sdk_1.configureSDK)(disputeParameters.options.sdkConfig);
+    }
+    const { disputeId, dtrSubgraph, coreSubgraph, options } = disputeParameters;
+    const disputeDetails = await (0, fetchDisputeDetails_1.default)(coreSubgraph, disputeId);
+    if (!disputeDetails?.dispute) {
+        throw new errors_1.NotFoundError("Dispute Details", `Dispute details not found for disputeId: ${disputeId}`);
+    }
+    const template = await (0, fetchDisputeTemplateFromId_1.default)(dtrSubgraph, disputeDetails.dispute.templateId);
+    if (!template) {
+        throw new errors_1.NotFoundError("Dispute Template", `Template not found for template ID: ${disputeDetails.dispute.templateId}`);
+    }
+    const { templateData, templateDataMappings } = template.disputeTemplate;
+    const initialContext = {
+        arbitrableAddress: disputeDetails.dispute.arbitrated.id,
+        arbitrableChainID: disputeDetails.dispute.arbitrableChainId,
+        externalDisputeID: disputeDetails.dispute.externalDisputeId,
+        ...options?.additionalContext,
+    };
+    let data = {};
+    if (templateDataMappings) {
+        try {
+            data = await (0, dataMappings_1.executeActions)(JSON.parse(templateDataMappings), initialContext);
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    const populatedTemplate = (0, utils_1.populateTemplate)(templateData, data);
+    return populatedTemplate;
+};
+exports.getDispute = getDispute;

package/lib/src/utils/index.d.ts

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

package/lib/src/utils/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("./getDispute"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kleros/kleros-sdk",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "SDK for Kleros version 2",
   "repository": "git@github.com:kleros/kleros-v2.git",
   "author": "Kleros",
@@ -30,7 +30,9 @@
     "test": "vitest",
     "test:ui": "vitest --ui",
     "test:run": "vitest run",
-    "publish": "yarn npm publish"
+    "release:patch": "scripts/publish.sh patch",
+    "release:minor": "scripts/publish.sh minor",
+    "release:major": "scripts/publish.sh major"
   },
   "devDependencies": {
     "@types/mustache": "^4.2.5",
@@ -42,10 +44,10 @@
     "vitest": "^1.1.3"
   },
   "dependencies": {
-    "@reality.eth/reality-eth-lib": "^3.2.30",
+    "@reality.eth/reality-eth-lib": "^3.2.43",
     "@urql/core": "^5.0.8",
     "mustache": "^4.2.0",
-    "viem": "^2.21.26",
+    "viem": "^2.21.35",
     "zod": "^3.22.4"
   }
 }