@jsm-mit/rabbit-motoko-package 0.1.0

package/declarations/rabbit-motoko-backend/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@icp-sdk/core/agent";
+import type { Principal } from "@icp-sdk/core/principal";
+import type { IDL } from "@icp-sdk/core/candid";
+
+import { _SERVICE } from './rabbit-motoko-backend.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const rabbit_motoko_backend: ActorSubclass<_SERVICE>;

package/declarations/rabbit-motoko-backend/index.js

@@ -0,0 +1,42 @@
+import { Actor, HttpAgent } from "@icp-sdk/core/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./rabbit-motoko-backend.did.js";
+export { idlFactory } from "./rabbit-motoko-backend.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_RABBIT_MOTOKO_BACKEND;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};
+
+export const rabbit_motoko_backend = canisterId ? createActor(canisterId) : undefined;

package/declarations/rabbit-motoko-backend/rabbit-motoko-backend.did

@@ -0,0 +1,39 @@
+type Task = 
+ record {
+   channel: text;
+   completedAt: int;
+   createdAt: int;
+   expiresAt: int;
+   id: nat;
+   parentIds: opt vec nat;
+   payload: text;
+   resultMessage: text;
+   status: nat;
+   timesOutAt: int;
+   worker: principal;
+ };
+type CompleteTaskArgs = 
+ record {
+   id: nat;
+   message: text;
+ };
+type ClaimTaskArgs = 
+ record {
+   id: nat;
+   timeoutNanos: int;
+ };
+type AddTaskArgs = 
+ record {
+   channel: text;
+   parentIds: opt vec nat;
+   payload: text;
+ };
+service : {
+  addTask: (args: AddTaskArgs) -> (nat);
+  claimTask: (args: ClaimTaskArgs) -> (opt Task);
+  completeTask: (args: CompleteTaskArgs) -> (bool);
+  getAvailableTaskIds: (channel: text) -> (vec nat) query;
+  getTask: (id: nat) -> (opt Task) query;
+  getTasks: () -> (vec Task) query;
+  getTasksLast24h: () -> (vec Task) query;
+}

package/declarations/rabbit-motoko-backend/rabbit-motoko-backend.did.d.ts

@@ -0,0 +1,35 @@
+import type { Principal } from '@icp-sdk/core/principal';
+import type { ActorMethod } from '@icp-sdk/core/agent';
+import type { IDL } from '@icp-sdk/core/candid';
+
+export interface AddTaskArgs {
+  'parentIds' : [] | [Array<bigint>],
+  'channel' : string,
+  'payload' : string,
+}
+export interface ClaimTaskArgs { 'id' : bigint, 'timeoutNanos' : bigint }
+export interface CompleteTaskArgs { 'id' : bigint, 'message' : string }
+export interface Task {
+  'id' : bigint,
+  'status' : bigint,
+  'completedAt' : bigint,
+  'resultMessage' : string,
+  'expiresAt' : bigint,
+  'timesOutAt' : bigint,
+  'createdAt' : bigint,
+  'parentIds' : [] | [Array<bigint>],
+  'worker' : Principal,
+  'channel' : string,
+  'payload' : string,
+}
+export interface _SERVICE {
+  'addTask' : ActorMethod<[AddTaskArgs], bigint>,
+  'claimTask' : ActorMethod<[ClaimTaskArgs], [] | [Task]>,
+  'completeTask' : ActorMethod<[CompleteTaskArgs], boolean>,
+  'getAvailableTaskIds' : ActorMethod<[string], Array<bigint>>,
+  'getTask' : ActorMethod<[bigint], [] | [Task]>,
+  'getTasks' : ActorMethod<[], Array<Task>>,
+  'getTasksLast24h' : ActorMethod<[], Array<Task>>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/declarations/rabbit-motoko-backend/rabbit-motoko-backend.did.js

@@ -0,0 +1,35 @@
+export const idlFactory = ({ IDL }) => {
+  const AddTaskArgs = IDL.Record({
+    'parentIds' : IDL.Opt(IDL.Vec(IDL.Nat)),
+    'channel' : IDL.Text,
+    'payload' : IDL.Text,
+  });
+  const ClaimTaskArgs = IDL.Record({
+    'id' : IDL.Nat,
+    'timeoutNanos' : IDL.Int,
+  });
+  const Task = IDL.Record({
+    'id' : IDL.Nat,
+    'status' : IDL.Nat,
+    'completedAt' : IDL.Int,
+    'resultMessage' : IDL.Text,
+    'expiresAt' : IDL.Int,
+    'timesOutAt' : IDL.Int,
+    'createdAt' : IDL.Int,
+    'parentIds' : IDL.Opt(IDL.Vec(IDL.Nat)),
+    'worker' : IDL.Principal,
+    'channel' : IDL.Text,
+    'payload' : IDL.Text,
+  });
+  const CompleteTaskArgs = IDL.Record({ 'id' : IDL.Nat, 'message' : IDL.Text });
+  return IDL.Service({
+    'addTask' : IDL.Func([AddTaskArgs], [IDL.Nat], []),
+    'claimTask' : IDL.Func([ClaimTaskArgs], [IDL.Opt(Task)], []),
+    'completeTask' : IDL.Func([CompleteTaskArgs], [IDL.Bool], []),
+    'getAvailableTaskIds' : IDL.Func([IDL.Text], [IDL.Vec(IDL.Nat)], ['query']),
+    'getTask' : IDL.Func([IDL.Nat], [IDL.Opt(Task)], ['query']),
+    'getTasks' : IDL.Func([], [IDL.Vec(Task)], ['query']),
+    'getTasksLast24h' : IDL.Func([], [IDL.Vec(Task)], ['query']),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { RabbitMotokoActor } from "./rabbit-motoko-actor.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { RabbitMotokoActor } from "./rabbit-motoko-actor.js";

package/dist/rabbit-motoko-actor.d.ts

@@ -0,0 +1,33 @@
+import type { AddTaskArgs, ClaimTaskArgs, CompleteTaskArgs, Task } from "../declarations/rabbit-motoko-backend/rabbit-motoko-backend.did.js";
+export declare class RabbitMotokoActor {
+    private readonly canisterId;
+    private readonly host;
+    private actor;
+    private agent;
+    constructor(canisterId: string);
+    private initActor;
+    private setupAgent;
+    private checkError;
+    sync(): Promise<void>;
+    /**
+     * Adds a new task to the queue.
+     */
+    addTask(args: AddTaskArgs): Promise<bigint>;
+    /**
+     * Claims a task for a specific worker.
+     */
+    claimTask(args: ClaimTaskArgs): Promise<[] | [Task]>;
+    /**
+     * Completes a previously claimed task.
+     */
+    completeTask(args: CompleteTaskArgs): Promise<boolean>;
+    /**
+     * Fetches IDs of tasks available in a specific channel.
+     */
+    getAvailableTaskIds(channel: string): Promise<bigint[]>;
+    /**
+     * Returns a list of all tasks.
+     */
+    getTasks(): Promise<Task[]>;
+}
+//# sourceMappingURL=rabbit-motoko-actor.d.ts.map

package/dist/rabbit-motoko-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbit-motoko-actor.d.ts","sourceRoot":"","sources":["../src/rabbit-motoko-actor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAER,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,IAAI,EACP,MAAM,oEAAoE,CAAC;AAE5E,qBAAa,iBAAiB;IAKd,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAClD,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,KAAK,CAAY;gBAEI,UAAU,EAAE,MAAM;IAe/C,OAAO,CAAC,SAAS;YAOH,UAAU;YAWV,UAAU;IAQX,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IASlC;;OAEG;IACU,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAUxD;;OAEG;IACU,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IAUjE;;OAEG;IACU,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAUnE;;OAEG;IACU,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAUpE;;OAEG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;CAS3C"}

package/dist/rabbit-motoko-actor.js

@@ -0,0 +1,115 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+import { idlFactory } from "../declarations/rabbit-motoko-backend/index.js";
+export class RabbitMotokoActor {
+    constructor(canisterId) {
+        this.canisterId = canisterId;
+        this.host = "https://icp0.io";
+        // 1. Tworzymy agenta
+        this.agent = new HttpAgent({
+            host: this.host,
+            // Opcjonalnie: można zwiększyć margines akceptacji czasu (retryDelay), 
+            // ale syncTime() jest skuteczniejszym rozwiązaniem.
+        });
+        // 2. Inicjalizujemy aktora
+        this.initActor();
+        // 3. Odpalamy asynchroniczną synchronizację
+        this.setupAgent();
+    }
+    initActor() {
+        this.actor = Actor.createActor(idlFactory, {
+            agent: this.agent,
+            canisterId: this.canisterId,
+        });
+    }
+    async setupAgent() {
+        try {
+            // Synchronizacja czasu z siecią IC - rozwiązuje błąd "certificate is still too far in the future"
+            await this.agent.syncTime();
+            console.log("✅ Agent IC zsynchronizowany pomyślnie.");
+        }
+        catch (err) {
+            console.error("❌ Błąd podczas konfiguracji Agenta:", err);
+        }
+    }
+    async checkError(error) {
+        const errorMsg = error?.toString() || "";
+        if (errorMsg.includes("certificate") || errorMsg.includes("TrustError")) {
+            console.warn("⚠️ Wykryto problem z zaufaniem/czasem. Próbuję synchronizacji...");
+            await this.sync();
+        }
+    }
+    async sync() {
+        try {
+            await this.agent.syncTime();
+            console.log("🔄 Czas agenta został zsynchronizowany ponownie.");
+        }
+        catch (err) {
+            console.error("❌ Nie udało się zsynchronizować czasu:", err);
+        }
+    }
+    /**
+     * Adds a new task to the queue.
+     */
+    async addTask(args) {
+        try {
+            return await this.actor.addTask(args);
+        }
+        catch (error) {
+            await this.checkError(error);
+            console.error(`❌ Błąd podczas dodawania zadania:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Claims a task for a specific worker.
+     */
+    async claimTask(args) {
+        try {
+            return await this.actor.claimTask(args);
+        }
+        catch (error) {
+            await this.checkError(error);
+            console.error(`❌ Błąd podczas pobierania zadania (claimTask):`, error);
+            throw error;
+        }
+    }
+    /**
+     * Completes a previously claimed task.
+     */
+    async completeTask(args) {
+        try {
+            return await this.actor.completeTask(args);
+        }
+        catch (error) {
+            await this.checkError(error);
+            console.error(`❌ Błąd podczas zakończenia zadania:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Fetches IDs of tasks available in a specific channel.
+     */
+    async getAvailableTaskIds(channel) {
+        try {
+            return await this.actor.getAvailableTaskIds(channel);
+        }
+        catch (error) {
+            await this.checkError(error);
+            console.error(`❌ Błąd podczas pobierania ID zadań (Kanał: ${channel}):`, error);
+            throw error;
+        }
+    }
+    /**
+     * Returns a list of all tasks.
+     */
+    async getTasks() {
+        try {
+            return await this.actor.getTasks();
+        }
+        catch (error) {
+            await this.checkError(error);
+            console.error(`❌ Błąd podczas pobierania wszystkich zadań (getTasks):`, error);
+            throw error;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@jsm-mit/rabbit-motoko-package",
+  "version": "0.1.0",
+  "description": "Wrapper TypeScript package for Rabbit Motoko IC actor using @dfinity/agent.",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "declarations/"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "clean": "rm -rf dist",
+    "prepare": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "@dfinity/agent": "^3.4.3"
+  }
+}