@veoow/synx-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+interface PipelineStep {
+    contract: string;
+    function: string;
+    payload: Record<string, unknown>;
+}
+interface PipelineStepResult {
+    contract: string;
+    function: string;
+    executionHash: string;
+    success: boolean;
+    contextId: string;
+    events: PipelineEvent[];
+}
+interface PipelineEvent {
+    Hash: string;
+    Payload: {
+        data: Record<string, unknown>;
+    };
+    Type: string;
+}
+interface PipelineOutput {
+    contextId: string;
+    steps: PipelineStepResult[];
+}
+
+interface RunInput {
+    contract: string;
+    function: string;
+    payload: Record<string, unknown>;
+    contextId?: string;
+}
+interface RunOutput {
+    executionHash: string;
+    function: string;
+    success: boolean;
+    contextId: string;
+    events: Record<string, any>;
+}
+
+interface TraceStep {
+    function: string;
+    executionHash: string;
+    parentHash: string | null;
+    contract: string;
+    executedAt: number;
+    success: boolean;
+    data: Record<string, unknown>;
+}
+interface TraceOutput {
+    contextId: string;
+    status: "COMPLETED" | "PARTIAL" | "FAILED";
+    steps: TraceStep[];
+}
+
+declare class Synx {
+    private readonly endpoint;
+    private readonly privKey;
+    private client;
+    private ready;
+    constructor(endpoint: string, privKey: string);
+    run(input: any): Promise<RunOutput>;
+    pipeline(steps: PipelineStep[], contextId?: string): Promise<PipelineOutput>;
+    trace(contextId: string): Promise<TraceOutput>;
+    private withRetry;
+    private authenticate;
+    private ensureReady;
+}
+
+interface Decision {
+    decisionId: string;
+    blockIndex: number;
+    hash: string;
+}
+
+export { type Decision, type RunInput, type RunOutput, Synx };

package/dist/index.js

@@ -0,0 +1,187 @@
+// src/errors.ts
+var TokenExpiredError = class extends Error {
+  constructor() {
+    super("Token expired");
+    this.name = "TokenExpiredError";
+  }
+};
+var SynxError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "SynxError";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/execution/pipeline.ts
+async function pipeline(client, steps, contextId) {
+  if (steps.length === 0) {
+    throw new Error("Pipeline must have at least one step");
+  }
+  const resolvedContextId = contextId ?? crypto.randomUUID();
+  const results = [];
+  for (const step of steps) {
+    const payload = {
+      function: step.function,
+      args: step.payload,
+      context_id: resolvedContextId
+    };
+    const res = await client.post(`/contracts/${step.contract}/execute`, payload);
+    results.push({
+      contract: step.contract,
+      function: step.function,
+      executionHash: res.executionHash,
+      success: res.success,
+      contextId: res.contextId,
+      events: res.events ?? []
+    });
+  }
+  return { contextId: resolvedContextId, steps: results };
+}
+
+// src/utils/http-client.ts
+var HttpClient = class {
+  constructor(endpoint, token) {
+    this.endpoint = endpoint;
+    this.token = token;
+  }
+  // Permite atualizar o token sem recriar o client
+  setToken(token) {
+    this.token = token;
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.endpoint}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (res.status === 401) throw new TokenExpiredError();
+    if (!res.ok)
+      throw new SynxError(
+        `HTTP POST ${path} failed: ${res.statusText}`,
+        res.status
+      );
+    return res.json();
+  }
+  async get(path) {
+    const res = await fetch(`${this.endpoint}${path}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.token}`
+      }
+    });
+    if (res.status === 401) throw new TokenExpiredError();
+    if (!res.ok)
+      throw new SynxError(
+        `HTTP GET ${path} failed: ${res.statusText}`,
+        res.status
+      );
+    return res.json();
+  }
+};
+
+// src/execution/run.ts
+async function run(client, input) {
+  const dto = validateCommit(input);
+  const body = {
+    function: dto.function,
+    args: dto.payload,
+    ...dto.contextId ? { context_id: dto.contextId } : {}
+  };
+  return client.post(`/contracts/${dto.contract}/execute`, body);
+}
+function validateCommit(input) {
+  if (!input.contract) throw new Error("Commit Input: 'contract' is required");
+  if (!input.function) throw new Error("Commit Input: 'function' is required");
+  if (input.payload === void 0)
+    throw new Error("Commit Input: 'payload' is required");
+  return input;
+}
+
+// src/execution/trace.ts
+async function trace(client, contextId) {
+  if (!contextId) throw new Error("Trace: 'contextId' is required");
+  return client.get(`/trace/${contextId}`);
+}
+
+// src/utils/jwt.ts
+import { Buffer } from "buffer";
+import { createPrivateKey, sign } from "crypto";
+function base64url(data) {
+  if (typeof data === "string") {
+    return Buffer.from(data).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  return Buffer.from(data).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function generateJWT(privKeyHex) {
+  const privKeyBytes = Buffer.from(privKeyHex, "hex");
+  const privKey = createPrivateKey({
+    key: privKeyBytes,
+    format: "der",
+    type: "pkcs8"
+  });
+  const header = base64url(JSON.stringify({ alg: "EdDSA", typ: "JWT" }));
+  const payload = base64url(
+    JSON.stringify({
+      iat: Math.floor(Date.now() / 1e3),
+      exp: Math.floor(Date.now() / 1e3) + 3600,
+      iss: "synx-sdk",
+      aud: "eeapi"
+    })
+  );
+  const data = `${header}.${payload}`;
+  const signature = sign(null, Buffer.from(data), privKey);
+  return `${data}.${base64url(signature)}`;
+}
+
+// src/client/synx-client.ts
+var Synx = class {
+  endpoint;
+  privKey;
+  client;
+  ready;
+  constructor(endpoint, privKey) {
+    this.endpoint = endpoint;
+    this.privKey = privKey;
+    this.ready = this.authenticate();
+  }
+  async run(input) {
+    return this.withRetry(() => run(this.client, input));
+  }
+  async pipeline(steps, contextId) {
+    return this.withRetry(() => pipeline(this.client, steps, contextId));
+  }
+  async trace(contextId) {
+    return this.withRetry(() => trace(this.client, contextId));
+  }
+  async withRetry(fn) {
+    await this.ensureReady();
+    try {
+      return await fn();
+    } catch (e) {
+      if (e instanceof TokenExpiredError) {
+        await this.authenticate();
+        return fn();
+      }
+      throw e;
+    }
+  }
+  async authenticate() {
+    const token = await generateJWT(this.privKey);
+    if (this.client) {
+      this.client.setToken(token);
+    } else {
+      this.client = new HttpClient(this.endpoint, token);
+    }
+  }
+  async ensureReady() {
+    await this.ready;
+  }
+};
+export {
+  Synx
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@veoow/synx-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "Apache-2.0",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}

package/src/client/synx-client.ts

@@ -0,0 +1,64 @@
+import { TokenExpiredError } from "../errors.js";
+import { pipeline } from "../execution/pipeline.js";
+import { run } from "../execution/run.js";
+import { trace } from "../execution/trace.js";
+import type { PipelineOutput, PipelineStep } from "../types/pipeline.js";
+import type { RunOutput } from "../types/run.js";
+import type { TraceOutput } from "../types/trace.js";
+import { HttpClient } from "../utils/http-client.js";
+import { generateJWT } from "../utils/jwt.js";
+
+export class Synx {
+  private readonly endpoint: string;
+  private readonly privKey: string;
+  private client!: HttpClient;
+  private ready: Promise<void>;
+
+  constructor(endpoint: string, privKey: string) {
+    this.endpoint = endpoint;
+    this.privKey = privKey;
+    this.ready = this.authenticate();
+  }
+
+  async run(input: any): Promise<RunOutput> {
+    return this.withRetry(() => run(this.client, input));
+  }
+
+  async pipeline(
+    steps: PipelineStep[],
+    contextId?: string,
+  ): Promise<PipelineOutput> {
+    return this.withRetry(() => pipeline(this.client, steps, contextId));
+  }
+
+  async trace(contextId: string): Promise<TraceOutput> {
+    return this.withRetry(() => trace(this.client, contextId));
+  }
+
+  private async withRetry<T>(fn: () => Promise<T>): Promise<T> {
+    await this.ensureReady();
+    try {
+      return await fn();
+    } catch (e) {
+      if (e instanceof TokenExpiredError) {
+        await this.authenticate();
+        return fn();
+      }
+      throw e;
+    }
+  }
+
+  private async authenticate(): Promise<void> {
+    const token = await generateJWT(this.privKey);
+
+    if (this.client) {
+      this.client.setToken(token);
+    } else {
+      this.client = new HttpClient(this.endpoint, token);
+    }
+  }
+
+  private async ensureReady(): Promise<void> {
+    await this.ready;
+  }
+}

package/src/errors.ts

@@ -0,0 +1,15 @@
+export class TokenExpiredError extends Error {
+  constructor() {
+    super("Token expired");
+    this.name = "TokenExpiredError";
+  }
+}
+
+export class SynxError extends Error {
+  statusCode: number;
+  constructor(message: string, statusCode: number) {
+    super(message);
+    this.name = "SynxError";
+    this.statusCode = statusCode;
+  }
+}

package/src/execution/pipeline.ts

@@ -0,0 +1,46 @@
+import type {
+  PipelineEvent,
+  PipelineOutput,
+  PipelineStep,
+  PipelineStepResult,
+} from "../types/pipeline.js";
+import type { HttpClient } from "../utils/http-client.js";
+
+export async function pipeline(
+  client: HttpClient,
+  steps: PipelineStep[],
+  contextId?: string,
+): Promise<PipelineOutput> {
+  if (steps.length === 0) {
+    throw new Error("Pipeline must have at least one step");
+  }
+
+  const resolvedContextId = contextId ?? crypto.randomUUID();
+  const results: PipelineStepResult[] = [];
+
+  for (const step of steps) {
+    const payload = {
+      function: step.function,
+      args: step.payload,
+      context_id: resolvedContextId,
+    };
+
+    const res = await client.post<{
+      executionHash: string;
+      success: boolean;
+      executedAt: string;
+      contextId: string;
+      events?: PipelineEvent[];
+    }>(`/contracts/${step.contract}/execute`, payload);
+    results.push({
+      contract: step.contract,
+      function: step.function,
+      executionHash: res.executionHash,
+      success: res.success,
+      contextId: res.contextId,
+      events: res.events ?? [],
+    });
+  }
+
+  return { contextId: resolvedContextId, steps: results };
+}

package/src/execution/run.ts

@@ -0,0 +1,26 @@
+import type { RunInput, RunOutput } from "../types/run.js";
+import { HttpClient } from "../utils/http-client.js";
+
+export async function run(
+  client: HttpClient,
+  input: RunInput,
+): Promise<RunOutput> {
+  const dto = validateCommit(input);
+
+  const body = {
+    function: dto.function,
+    args: dto.payload,
+    ...(dto.contextId ? { context_id: dto.contextId } : {}),
+  };
+
+  return client.post(`/contracts/${dto.contract}/execute`, body);
+}
+
+function validateCommit(input: Partial<RunInput>): RunInput {
+  if (!input.contract) throw new Error("Commit Input: 'contract' is required");
+  if (!input.function) throw new Error("Commit Input: 'function' is required");
+  if (input.payload === undefined)
+    throw new Error("Commit Input: 'payload' is required");
+
+  return input as RunInput;
+}

package/src/execution/trace.ts

@@ -0,0 +1,10 @@
+import type { TraceOutput } from "../types/trace.js";
+import { HttpClient } from "../utils/http-client.js";
+
+export async function trace(
+  client: HttpClient,
+  contextId: string,
+): Promise<TraceOutput> {
+  if (!contextId) throw new Error("Trace: 'contextId' is required");
+  return client.get(`/trace/${contextId}`);
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { Synx } from "./client/synx-client.js";
+
+export * from "./types/run.js";
+export * from "./types/decision.js";

package/src/types/decision.ts

@@ -0,0 +1,5 @@
+export interface Decision {
+  decisionId: string;
+  blockIndex: number;
+  hash: string;
+}

package/src/types/pipeline.ts

@@ -0,0 +1,25 @@
+export interface PipelineStep {
+  contract: string;
+  function: string;
+  payload: Record<string, unknown>;
+}
+
+export interface PipelineStepResult {
+  contract: string;
+  function: string;
+  executionHash: string;
+  success: boolean;
+  contextId: string;
+  events: PipelineEvent[];
+}
+
+export interface PipelineEvent {
+  Hash: string;
+  Payload: { data: Record<string, unknown> };
+  Type: string;
+}
+
+export interface PipelineOutput {
+  contextId: string;
+  steps: PipelineStepResult[];
+}

package/src/types/run.ts

@@ -0,0 +1,15 @@
+// src/types/run.ts
+export interface RunInput {
+  contract: string;
+  function: string;
+  payload: Record<string, unknown>;
+  contextId?: string;
+}
+
+export interface RunOutput {
+  executionHash: string;
+  function: string;
+  success: boolean;
+  contextId: string;
+  events: Record<string, any>;
+}

package/src/types/trace.ts

@@ -0,0 +1,15 @@
+export interface TraceStep {
+  function: string;
+  executionHash: string;
+  parentHash: string | null;
+  contract: string;
+  executedAt: number;
+  success: boolean;
+  data: Record<string, unknown>;
+}
+
+export interface TraceOutput {
+  contextId: string;
+  status: "COMPLETED" | "PARTIAL" | "FAILED";
+  steps: TraceStep[];
+}

package/src/utils/http-client.ts

@@ -0,0 +1,51 @@
+import { TokenExpiredError, SynxError } from "../errors.js";
+
+export class HttpClient {
+  constructor(
+    private readonly endpoint: string,
+    private token: string,
+  ) {}
+
+  // Permite atualizar o token sem recriar o client
+  setToken(token: string) {
+    this.token = token;
+  }
+
+  async post<T>(path: string, body: unknown): Promise<T> {
+    const res = await fetch(`${this.endpoint}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (res.status === 401) throw new TokenExpiredError();
+    if (!res.ok)
+      throw new SynxError(
+        `HTTP POST ${path} failed: ${res.statusText}`,
+        res.status,
+      );
+
+    return res.json();
+  }
+
+  async get<T>(path: string): Promise<T> {
+    const res = await fetch(`${this.endpoint}${path}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+      },
+    });
+
+    if (res.status === 401) throw new TokenExpiredError();
+    if (!res.ok)
+      throw new SynxError(
+        `HTTP GET ${path} failed: ${res.statusText}`,
+        res.status,
+      );
+
+    return res.json();
+  }
+}

package/src/utils/jwt.ts

@@ -0,0 +1,42 @@
+import { Buffer } from "node:buffer";
+import { createPrivateKey, sign } from "node:crypto";
+
+function base64url(data: Buffer | Uint8Array | string): string {
+  if (typeof data === "string") {
+    return Buffer.from(data)
+      .toString("base64")
+      .replace(/\+/g, "-")
+      .replace(/\//g, "_")
+      .replace(/=/g, "");
+  }
+  return Buffer.from(data)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+}
+
+export function generateJWT(privKeyHex: string): string {
+  const privKeyBytes = Buffer.from(privKeyHex, "hex");
+
+  const privKey = createPrivateKey({
+    key: privKeyBytes,
+    format: "der",
+    type: "pkcs8",
+  });
+
+  const header = base64url(JSON.stringify({ alg: "EdDSA", typ: "JWT" }));
+  const payload = base64url(
+    JSON.stringify({
+      iat: Math.floor(Date.now() / 1000),
+      exp: Math.floor(Date.now() / 1000) + 3600,
+      iss: "synx-sdk",
+      aud: "eeapi",
+    }),
+  );
+
+  const data = `${header}.${payload}`;
+  const signature = sign(null, Buffer.from(data), privKey);
+
+  return `${data}.${base64url(signature)}`;
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    // "rootDir": "./src",
+    // "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    // "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  }
+}