@kleros/kleros-sdk 2.1.1 → 2.1.2

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 "src/dataMappings/utils/actionTypes";
+export declare const callAction: (mapping: AbiCallMapping) => Promise<Record<string, any>>;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAction = void 0;
+const viem_1 = require("viem");
+const createResultObject_1 = require("src/dataMappings/utils/createResultObject");
+const sdk_1 = require("src/sdk");
+const callAction = async (mapping) => {
+    const publicClient = (0, sdk_1.getPublicClient)();
+    if (!publicClient) {
+        throw new Error("SDK not configured. Please call `configureSDK` before using.");
+    }
+    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 "src/dataMappings/utils/actionTypes";
+export declare const eventAction: (mapping: AbiEventMapping) => Promise<Record<string, any>>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventAction = void 0;
+const viem_1 = require("viem");
+const createResultObject_1 = require("src/dataMappings/utils/createResultObject");
+const sdk_1 = require("src/sdk");
+const eventAction = async (mapping) => {
+    const publicClient = (0, sdk_1.getPublicClient)();
+    if (!publicClient) {
+        throw new Error("SDK not configured. Please call `configureSDK` before using.");
+    }
+    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 "src/dataMappings/utils/actionTypes";
+export declare const fetchIpfsJsonAction: (mapping: FetchIpfsJsonMapping) => Promise<Record<string, any>>;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchIpfsJsonAction = void 0;
+const createResultObject_1 = require("src/dataMappings/utils/createResultObject");
+const consts_1 = require("src/consts");
+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 Error("Invalid IPFS URI format");
+    }
+    const response = await fetch(httpUri, { method: "GET" });
+    if (!response.ok) {
+        throw new Error("Failed to fetch data from IPFS");
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && parseInt(contentLength) > consts_1.MAX_BYTE_SIZE) {
+        throw new Error("Response size is too large");
+    }
+    const contentType = response.headers.get("content-type");
+    if (!contentType || !contentType.includes("application/json")) {
+        throw new Error("Fetched data is not JSON");
+    }
+    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("src/dataMappings/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("src/dataMappings/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/disputeDetails.d.ts

@@ -0,0 +1,35 @@
+export type DisputeDetails = {
+    title: string;
+    description: string;
+    question: string;
+    type: QuestionType;
+    answers: Answer[];
+    policyURI: string;
+    attachment: Attachment;
+    frontendUrl: string;
+    arbitrableChainID: string;
+    arbitrableAddress: `0x${string}`;
+    arbitratorChainID: string;
+    arbitratorAddress: `0x${string}`;
+    category: string;
+    lang: string;
+    specification: string;
+    version: string;
+};
+export declare enum QuestionType {
+    Bool = "bool",
+    Datetime = "datetime",
+    MultipleSelect = "multiple-select",
+    SingleSelect = "single-select",
+    Uint = "uint"
+}
+export type Answer = {
+    title: string;
+    description: string;
+    id: `0x${string}`;
+    reserved: boolean;
+};
+export type Attachment = {
+    label: string;
+    uri: string;
+};

package/lib/src/dataMappings/disputeDetails.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionType = void 0;
+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 = {}));

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,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeActions = exports.executeAction = void 0;
+const callAction_1 = require("./actions/callAction");
+const eventAction_js_1 = require("./actions/eventAction.js");
+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_js_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 Error(`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/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,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveRealityData = void 0;
+const executeActions_1 = require("./executeActions");
+const retrieveRealityData = async (realityQuestionID, arbitrable) => {
+    if (!arbitrable) {
+        throw new Error("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 || !questionData) {
+        throw new Error("Failed to retrieve template or 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, RealityMapping } 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) => RealityMapping;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRealityMapping = exports.validateFetchIpfsJsonMapping = exports.validateJsonMapping = exports.validateAbiCallMapping = exports.validateAbiEventMapping = exports.validateSubgraphMapping = void 0;
+const validateSubgraphMapping = (mapping) => {
+    if (mapping.endpoint === undefined) {
+        throw new Error("Invalid mapping for graphql action.");
+    }
+    return mapping;
+};
+exports.validateSubgraphMapping = validateSubgraphMapping;
+const validateAbiEventMapping = (mapping) => {
+    if (mapping.abi === undefined || mapping.eventFilter === undefined) {
+        throw new Error("Invalid mapping for abi/event action.");
+    }
+    return mapping;
+};
+exports.validateAbiEventMapping = validateAbiEventMapping;
+const validateAbiCallMapping = (mapping) => {
+    if (mapping.abi === undefined || mapping.functionName === undefined) {
+        throw new Error("Invalid mapping for abi/call action.");
+    }
+    return mapping;
+};
+exports.validateAbiCallMapping = validateAbiCallMapping;
+const validateJsonMapping = (mapping) => {
+    if (mapping.value === undefined) {
+        throw new Error("Invalid mapping for json action.");
+    }
+    return mapping;
+};
+exports.validateJsonMapping = validateJsonMapping;
+const validateFetchIpfsJsonMapping = (mapping) => {
+    if (mapping.ipfsUri === undefined) {
+        throw new Error("Invalid mapping for fetch/ipfs/json action.");
+    }
+    return mapping;
+};
+exports.validateFetchIpfsJsonMapping = validateFetchIpfsJsonMapping;
+const validateRealityMapping = (mapping) => {
+    if (mapping.type !== "reality" || typeof mapping.realityQuestionID !== "string") {
+        throw new Error("Invalid mapping for reality action.");
+    }
+    return mapping;
+};
+exports.validateRealityMapping = validateRealityMapping;

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/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,20 @@
+"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 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 Error("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,35 @@
+"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"));
+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 Error(`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/index.d.ts

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

package/lib/src/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("./sdk"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/getDispute"), 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: number) => Promise<DisputeDetailsQueryResponse>;
+export default fetchDisputeDetails;

package/lib/src/requests/fetchDisputeDetails.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_request_1 = require("graphql-request");
+const fetchDisputeDetails = async (endpoint, id) => {
+    const query = `
+    query DisputeDetails {
+    dispute(id: ${id}) {
+        arbitrated {
+            id
+        }
+        arbitrableChainId
+        externalDisputeId
+        templateId
+    }
+  }
+`;
+    try {
+        return await (0, graphql_request_1.request)(endpoint, query);
+    }
+    catch (error) {
+        throw new Error(`Error querying Dispute Details , endpoint : ${endpoint}, message : ${error?.message}`);
+    }
+};
+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>;
+export default fetchDisputeTemplateFromId;

package/lib/src/requests/fetchDisputeTemplateFromId.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_request_1 = require("graphql-request");
+const fetchDisputeTemplateFromId = async (endpoint, id) => {
+    const query = `
+    query DisputeTemplate {
+        disputeTemplate(id: ${id}) {
+            templateData
+            templateDataMappings
+        }
+    }
+`;
+    try {
+        return await (0, graphql_request_1.request)(endpoint, query);
+    }
+    catch (error) {
+        throw new Error(`Error querying Dispute Template Registry , endpoint : ${endpoint}, message : ${error?.message}`);
+    }
+};
+exports.default = fetchDisputeTemplateFromId;

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,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicClient = exports.configureSDK = void 0;
+const viem_1 = require("viem");
+let publicClient;
+const configureSDK = (config) => {
+    if (config.client) {
+        publicClient = (0, viem_1.createPublicClient)(config.client);
+    }
+};
+exports.configureSDK = configureSDK;
+const getPublicClient = () => {
+    if (!publicClient) {
+        throw new Error("SDK not configured. Please call `configureSDK` before using.");
+    }
+    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: number;
+    coreSubgraph: string;
+    dtrSubgraph: string;
+    options: GetDisputeParametersOptions | undefined;
+};
+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 { type GetDisputeParameters } from "src/types";
+import { DisputeDetails } from "dataMappings/utils/disputeDetailsTypes";
+export declare const getDispute: (disputeParameters: GetDisputeParameters) => Promise<DisputeDetails | undefined>;

package/lib/src/utils/getDispute.js

@@ -0,0 +1,44 @@
+"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 sdk_1 = require("src/sdk");
+const fetchDisputeDetails_1 = __importDefault(require("src/requests/fetchDisputeDetails"));
+const fetchDisputeTemplateFromId_1 = __importDefault(require("src/requests/fetchDisputeTemplateFromId"));
+const executeActions_1 = require("dataMappings/executeActions");
+const populateTemplate_1 = require("dataMappings/utils/populateTemplate");
+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 Error(`Dispute details not found for disputeId: ${disputeId}`);
+    }
+    const template = await (0, fetchDisputeTemplateFromId_1.default)(dtrSubgraph, disputeDetails.dispute.templateId);
+    if (!template) {
+        throw new Error(`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, executeActions_1.executeActions)(JSON.parse(templateDataMappings), initialContext);
+        }
+        catch (err) {
+            throw new Error(err);
+        }
+    }
+    const populatedTemplate = (0, populateTemplate_1.populateTemplate)(templateData, data);
+    return populatedTemplate;
+};
+exports.getDispute = getDispute;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kleros/kleros-sdk",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "SDK for Kleros version 2",
   "repository": "git@github.com:kleros/kleros-v2.git",
   "author": "Kleros",