@gibwork/sdk 0.0.1

package/dist/node.cjs

@@ -0,0 +1,870 @@
+'use strict';
+
+var crypto = require('crypto');
+var sanitizeHtml = require('sanitize-html');
+var web3_js = require('@solana/web3.js');
+var bs58 = require('bs58');
+var nacl = require('tweetnacl');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var sanitizeHtml__default = /*#__PURE__*/_interopDefault(sanitizeHtml);
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
+var nacl__default = /*#__PURE__*/_interopDefault(nacl);
+
+// src/config.ts
+var FALLBACK_GIBWORK_API_URL = "https://sdk.gib.work";
+var DEFAULT_GIBWORK_API_URL = "https://sdk.gib.work"?.trim() || FALLBACK_GIBWORK_API_URL;
+
+// src/errors/index.ts
+var GibworkError = class extends Error {
+  name = "GibworkError";
+};
+var GibworkConfigurationError = class extends GibworkError {
+  name = "GibworkConfigurationError";
+};
+var GibworkApiError = class extends GibworkError {
+  constructor(status, body, method, path, requestId) {
+    super(`Gibwork API request failed with HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+    this.method = method;
+    this.path = path;
+    this.requestId = requestId;
+  }
+  status;
+  body;
+  method;
+  path;
+  requestId;
+  name = "GibworkApiError";
+};
+var GibworkNetworkError = class extends GibworkError {
+  constructor(message, method, path, options) {
+    super(message, options);
+    this.method = method;
+    this.path = path;
+  }
+  method;
+  path;
+  name = "GibworkNetworkError";
+};
+var GibworkTimeoutError = class extends GibworkNetworkError {
+  constructor(method, path, timeoutMs, options) {
+    super(
+      `Gibwork API request timed out after ${timeoutMs}ms`,
+      method,
+      path,
+      options
+    );
+    this.timeoutMs = timeoutMs;
+  }
+  timeoutMs;
+  name = "GibworkTimeoutError";
+};
+var GibworkRequestAbortedError = class extends GibworkNetworkError {
+  name = "GibworkRequestAbortedError";
+  constructor(method, path, options) {
+    super("Gibwork API request was aborted", method, path, options);
+  }
+};
+var GibworkAmbiguousSubmitError = class extends GibworkNetworkError {
+  constructor(method, path, context, options) {
+    super(
+      "The transaction submit outcome is unknown; do not submit the same intent again",
+      method,
+      path,
+      options
+    );
+    this.context = context;
+  }
+  context;
+  name = "GibworkAmbiguousSubmitError";
+};
+var HTML_SANITIZE_OPTIONS = {
+  allowedTags: sanitizeHtml__default.default.defaults.allowedTags.concat(["img"]),
+  allowedAttributes: {
+    ...sanitizeHtml__default.default.defaults.allowedAttributes,
+    "*": ["class", "id", "style", "data-type"],
+    a: ["href", "name", "target"],
+    img: [
+      "src",
+      "srcset",
+      "alt",
+      "title",
+      "limit",
+      "width",
+      "height",
+      "loading",
+      "maxSize",
+      "fileid"
+    ]
+  },
+  transformTags: {
+    a: (tagName, attributes) => {
+      if (isAllowedExternalUrl(attributes.href)) {
+        return { tagName, attribs: attributes };
+      }
+      const safeAttributes = { ...attributes };
+      delete safeAttributes.href;
+      return { tagName: "span", attribs: safeAttributes };
+    }
+  }
+};
+function sanitizeContent(content) {
+  return sanitizeHtml__default.default(content, HTML_SANITIZE_OPTIONS).trim();
+}
+function isAllowedExternalUrl(value) {
+  if (!value) return false;
+  const normalized = value.toLowerCase().startsWith("www.") ? `https://${value}` : value;
+  try {
+    const url = new URL(normalized);
+    return (url.protocol === "http:" || url.protocol === "https:") && Boolean(url.hostname) && !url.username && !url.password;
+  } catch {
+    return false;
+  }
+}
+
+// src/auth/normalize.ts
+function normalizeCreateTask(input, walletAddress) {
+  const normalized = {
+    walletAddress: walletAddress.trim(),
+    title: input.title.trim(),
+    content: sanitizeContent(input.content),
+    tags: input.tags.map((tag) => tag.trim()),
+    payment: {
+      mintAddress: input.payment.mintAddress.trim(),
+      amount: input.payment.amount.trim()
+    },
+    minSubmissionAmount: input.minSubmissionAmount.trim(),
+    deadline: input.deadline ?? null,
+    allowOnlyVerifiedSubmissions: input.allowOnlyVerifiedSubmissions ?? false
+  };
+  const primarySkillSlug = trimOptional(input.primarySkillSlug)?.toLowerCase();
+  if (primarySkillSlug !== void 0 && primarySkillSlug !== null) {
+    normalized.primarySkillSlug = primarySkillSlug;
+  }
+  if (input.refundFeeOverride !== void 0 && input.refundFeeOverride !== null) {
+    normalized.refundFeeOverride = input.refundFeeOverride;
+  }
+  if (input.allowOnlyDiscordGuildSubmissions !== void 0) {
+    normalized.allowOnlyDiscordGuildSubmissions = input.allowOnlyDiscordGuildSubmissions;
+  }
+  const requiredDiscordGuildId = trimOptional(input.requiredDiscordGuildId);
+  if (requiredDiscordGuildId !== void 0) {
+    normalized.requiredDiscordGuildId = requiredDiscordGuildId;
+  }
+  const requiredDiscordGuildName = trimOptional(input.requiredDiscordGuildName);
+  if (requiredDiscordGuildName !== void 0) {
+    normalized.requiredDiscordGuildName = requiredDiscordGuildName;
+  }
+  const discordGuildInvitationUrl = trimOptional(
+    input.discordGuildInvitationUrl
+  );
+  if (discordGuildInvitationUrl !== void 0) {
+    normalized.discordGuildInvitationUrl = discordGuildInvitationUrl;
+  }
+  if (input.requiredDiscordRoleIds !== void 0) {
+    const roles = input.requiredDiscordRoleIds.map((role) => role.trim()).filter(Boolean);
+    if (roles.length > 0) normalized.requiredDiscordRoleIds = roles;
+  }
+  return normalized;
+}
+function normalizeTaskPagination(query = {}) {
+  return {
+    page: query.page ?? 1,
+    limit: query.limit ?? 15,
+    pageAll: query.pageAll ?? false
+  };
+}
+function normalizeSubmissionPagination(query = {}) {
+  return {
+    page: query.page ?? 1,
+    limit: query.limit ?? 15,
+    pageAll: query.pageAll ?? false,
+    status: query.status ?? null
+  };
+}
+function normalizeApproval(input, walletAddress) {
+  const normalized = {
+    walletAddress,
+    amount: input.amount.trim()
+  };
+  if (input.rating !== void 0) normalized.rating = input.rating;
+  return normalized;
+}
+function normalizeRejection(reason, walletAddress) {
+  return {
+    walletAddress,
+    rejectReason: typeof reason === "string" ? reason.trim() : reason ?? null
+  };
+}
+function normalizeComment(content, walletAddress) {
+  return {
+    walletAddress,
+    content: sanitizeContent(content)
+  };
+}
+function sha256Json(value) {
+  return crypto.createHash("sha256").update(JSON.stringify(value), "utf8").digest("hex");
+}
+function toQueryString(values) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(values)) {
+    if (value !== void 0 && value !== null) query.set(key, String(value));
+  }
+  return query.toString();
+}
+function trimOptional(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+async function createWalletAuthHeaders(signer, descriptor, dependencies = {}) {
+  const values = {
+    walletAddress: signer.publicKey.toBase58(),
+    timestamp: Math.floor(
+      (dependencies.now?.() ?? Date.now()) / 1e3
+    ).toString(),
+    nonce: dependencies.nonce?.() ?? crypto.randomUUID()
+  };
+  const message = buildWalletAuthMessage(descriptor, values);
+  const signature = await signer.signMessage(new TextEncoder().encode(message));
+  if (!(signature instanceof Uint8Array) || signature.length !== 64) {
+    throw new GibworkConfigurationError(
+      "WalletSigner.signMessage must return a 64-byte Ed25519 signature"
+    );
+  }
+  return {
+    "x-gibwork-wallet-address": values.walletAddress,
+    "x-gibwork-timestamp": values.timestamp,
+    "x-gibwork-nonce": values.nonce,
+    "x-gibwork-signature": Buffer.from(signature).toString("base64")
+  };
+}
+function buildWalletAuthMessage(descriptor, values) {
+  return [
+    descriptor.operation,
+    `method:${descriptor.method}`,
+    `path:${descriptor.path}`,
+    ...(descriptor.resourceFields ?? []).map(
+      ([name, value]) => `${name}:${value}`
+    ),
+    `walletAddress:${values.walletAddress}`,
+    `timestamp:${values.timestamp}`,
+    `nonce:${values.nonce}`,
+    `${descriptor.hash[0]}:${descriptor.hash[1]}`
+  ].join("\n");
+}
+async function signPreparedTransaction(serializedTransaction, signer) {
+  if (typeof serializedTransaction !== "string" || !serializedTransaction) {
+    throw new GibworkConfigurationError(
+      "serializedTransaction must be a non-empty base64 string"
+    );
+  }
+  let transaction;
+  try {
+    transaction = web3_js.VersionedTransaction.deserialize(
+      Buffer.from(serializedTransaction, "base64")
+    );
+  } catch (cause) {
+    throw new GibworkConfigurationError(
+      "serializedTransaction is not a valid Solana VersionedTransaction",
+      { cause }
+    );
+  }
+  const signed = await signer.signTransaction(transaction);
+  if (!(signed instanceof web3_js.VersionedTransaction)) {
+    throw new GibworkConfigurationError(
+      "WalletSigner.signTransaction must return a VersionedTransaction"
+    );
+  }
+  return Buffer.from(signed.serialize()).toString("base64");
+}
+
+// src/resources/submissions/submission-comments-resource.ts
+var SubmissionCommentsResource = class {
+  constructor(transport, signer) {
+    this.transport = transport;
+    this.signer = signer;
+  }
+  transport;
+  signer;
+  async list(taskId, submissionId, options) {
+    const path = commentsPath(taskId, submissionId);
+    const headers = await createWalletAuthHeaders(this.signer, {
+      operation: "gibwork:view-task-submission-comments",
+      method: "GET",
+      path,
+      resourceFields: [
+        ["taskId", taskId],
+        ["taskSubmissionId", submissionId]
+      ],
+      hash: ["queryHash", sha256Json({})]
+    });
+    return this.transport.request({
+      method: "GET",
+      path,
+      headers,
+      ...options ? { options } : {}
+    });
+  }
+  async create(taskId, submissionId, content, options) {
+    const path = commentsPath(taskId, submissionId);
+    const body = normalizeComment(content, this.signer.publicKey.toBase58());
+    const headers = await createWalletAuthHeaders(this.signer, {
+      operation: "gibwork:create-task-submission-comment",
+      method: "POST",
+      path,
+      resourceFields: [
+        ["taskId", taskId],
+        ["taskSubmissionId", submissionId]
+      ],
+      hash: ["payloadHash", sha256Json(body)]
+    });
+    return this.transport.request({
+      method: "POST",
+      path,
+      headers,
+      body,
+      ...options ? { options } : {}
+    });
+  }
+};
+function commentsPath(taskId, submissionId) {
+  return `/v2/int/tasks/${encodeURIComponent(taskId)}/submission/${encodeURIComponent(submissionId)}/comments`;
+}
+
+// src/resources/submissions/submissions-resource.ts
+var SubmissionsResource = class {
+  constructor(transport, signer) {
+    this.transport = transport;
+    this.signer = signer;
+    this.comments = new SubmissionCommentsResource(transport, signer);
+  }
+  transport;
+  signer;
+  comments;
+  async list(taskId, query = {}, options) {
+    const normalized = normalizeSubmissionPagination(query);
+    const path = `/v2/int/tasks/${encodeURIComponent(taskId)}/submissions`;
+    const headers = await createWalletAuthHeaders(this.signer, {
+      operation: "gibwork:view-task-submissions",
+      method: "GET",
+      path,
+      resourceFields: [["taskId", taskId]],
+      hash: ["queryHash", sha256Json(normalized)]
+    });
+    const requestQuery = { ...normalized };
+    if (requestQuery.status === null) delete requestQuery.status;
+    return this.transport.request({
+      method: "GET",
+      path: `${path}?${toQueryString(requestQuery)}`,
+      headers,
+      ...options ? { options } : {}
+    });
+  }
+  async approve(taskId, submissionId, input, options) {
+    const prepared = await this.prepareApproval(
+      taskId,
+      submissionId,
+      input,
+      options
+    );
+    const submitPath = approvalSubmitPath(
+      taskId,
+      submissionId,
+      prepared.intentId
+    );
+    assertNotAborted(options, submitPath);
+    const signedTransaction = await signPreparedTransaction(
+      prepared.serializedTransaction,
+      this.signer
+    );
+    assertNotAborted(options, submitPath);
+    const submitted = await this.submitApproval(
+      taskId,
+      submissionId,
+      prepared.intentId,
+      signedTransaction,
+      options
+    );
+    return {
+      ...submitted,
+      intentId: prepared.intentId,
+      lastValidBlockHeight: prepared.lastValidBlockHeight,
+      approvalQuote: prepared.approvalQuote
+    };
+  }
+  async reject(taskId, submissionId, reason, options) {
+    const path = `/v2/int/tasks/${encodeURIComponent(taskId)}/submission/${encodeURIComponent(submissionId)}/reject`;
+    const body = normalizeRejection(reason, this.walletAddress);
+    const headers = await createWalletAuthHeaders(this.signer, {
+      operation: "gibwork:reject-task-submission",
+      method: "POST",
+      path,
+      resourceFields: [
+        ["taskId", taskId],
+        ["taskSubmissionId", submissionId]
+      ],
+      hash: ["payloadHash", sha256Json(body)]
+    });
+    return this.transport.request({
+      method: "POST",
+      path,
+      headers,
+      body,
+      ...options ? { options } : {}
+    });
+  }
+  async prepareApproval(taskId, submissionId, input, options) {
+    const path = `/v2/int/tasks/${encodeURIComponent(taskId)}/submission/${encodeURIComponent(submissionId)}/pay`;
+    const body = normalizeApproval(input, this.walletAddress);
+    const headers = await createWalletAuthHeaders(this.signer, {
+      operation: "gibwork:approve-task-submission-intent",
+      method: "POST",
+      path,
+      resourceFields: [
+        ["taskId", taskId],
+        ["taskSubmissionId", submissionId]
+      ],
+      hash: ["payloadHash", sha256Json(body)]
+    });
+    return this.transport.request({
+      method: "POST",
+      path,
+      headers,
+      body,
+      ...options ? { options } : {}
+    });
+  }
+  async submitApproval(taskId, submissionId, intentId, signedTransaction, options) {
+    const path = approvalSubmitPath(taskId, submissionId, intentId);
+    return this.transport.request({
+      method: "POST",
+      path,
+      body: { signedTransaction },
+      ...options ? { options } : {},
+      ambiguousSubmit: {
+        operation: "approve-submission",
+        taskId,
+        submissionId,
+        intentId
+      }
+    });
+  }
+  get walletAddress() {
+    return this.signer.publicKey.toBase58();
+  }
+};
+function approvalSubmitPath(taskId, submissionId, intentId) {
+  return `/v2/int/tasks/${encodeURIComponent(taskId)}/submission/${encodeURIComponent(submissionId)}/pay/${encodeURIComponent(intentId)}/submit`;
+}
+function assertNotAborted(options, path) {
+  if (options?.signal?.aborted) {
+    throw new GibworkRequestAbortedError("POST", path, {
+      cause: options.signal.reason
+    });
+  }
+}
+
+// src/resources/tasks/tasks-resource.ts
+var TasksResource = class {
+  constructor(transport, signer) {
+    this.transport = transport;
+    this.signer = signer;
+  }
+  transport;
+  signer;
+  async create(input, options) {
+    const prepared = await this.prepareCreate(input, options);
+    assertNotAborted2(options, "/v2/int/tasks");
+    const signedTransaction = await signPreparedTransaction(
+      prepared.serializedTransaction,
+      this.signer
+    );
+    assertNotAborted2(
+      options,
+      `/v2/int/tasks/${encodeURIComponent(prepared.intentId)}/submit`
+    );
+    const submitted = await this.submitCreate(
+      prepared.intentId,
+      signedTransaction,
+      options
+    );
+    return {
+      ...submitted,
+      intentId: prepared.intentId,
+      lastValidBlockHeight: prepared.lastValidBlockHeight,
+      paymentQuote: prepared.paymentQuote
+    };
+  }
+  async list(query = {}, options) {
+    const normalized = normalizeTaskPagination(query);
+    const path = "/v2/int/tasks";
+    const headers = await this.auth({
+      operation: "gibwork:view-created-tasks",
+      method: "GET",
+      path,
+      hash: ["queryHash", sha256Json(normalized)]
+    });
+    return this.transport.request({
+      method: "GET",
+      path: `${path}?${toQueryString(normalized)}`,
+      headers,
+      ...options ? { options } : {}
+    });
+  }
+  async refund(taskId, options) {
+    const prepared = await this.prepareRefund(taskId, options);
+    const submitPath = `/v2/int/tasks/${encodeURIComponent(taskId)}/refund/${encodeURIComponent(prepared.intentId)}/submit`;
+    assertNotAborted2(options, submitPath);
+    const signedTransaction = await signPreparedTransaction(
+      prepared.serializedTransaction,
+      this.signer
+    );
+    assertNotAborted2(options, submitPath);
+    const submitted = await this.submitRefund(
+      taskId,
+      prepared.intentId,
+      signedTransaction,
+      options
+    );
+    return {
+      ...submitted,
+      intentId: prepared.intentId,
+      lastValidBlockHeight: prepared.lastValidBlockHeight,
+      refundQuote: prepared.refundQuote
+    };
+  }
+  async prepareCreate(input, options) {
+    const path = "/v2/int/tasks";
+    const body = normalizeCreateTask(input, this.walletAddress);
+    const headers = await this.auth({
+      operation: "gibwork:create-task-intent",
+      method: "POST",
+      path,
+      hash: ["payloadHash", sha256Json(body)]
+    });
+    return this.transport.request({
+      method: "POST",
+      path,
+      headers,
+      body,
+      ...options ? { options } : {}
+    });
+  }
+  async submitCreate(intentId, signedTransaction, options) {
+    const path = `/v2/int/tasks/${encodeURIComponent(intentId)}/submit`;
+    return this.transport.request({
+      method: "POST",
+      path,
+      body: { signedTransaction },
+      ...options ? { options } : {},
+      ambiguousSubmit: {
+        operation: "create-task",
+        intentId
+      }
+    });
+  }
+  async prepareRefund(taskId, options) {
+    const path = `/v2/int/tasks/${encodeURIComponent(taskId)}/refund`;
+    const body = { walletAddress: this.walletAddress };
+    const headers = await this.auth({
+      operation: "gibwork:refund-task-intent",
+      method: "POST",
+      path,
+      resourceFields: [["taskId", taskId]],
+      hash: ["payloadHash", sha256Json(body)]
+    });
+    return this.transport.request({
+      method: "POST",
+      path,
+      headers,
+      body,
+      ...options ? { options } : {}
+    });
+  }
+  async submitRefund(taskId, intentId, signedTransaction, options) {
+    const path = `/v2/int/tasks/${encodeURIComponent(taskId)}/refund/${encodeURIComponent(intentId)}/submit`;
+    return this.transport.request({
+      method: "POST",
+      path,
+      body: { signedTransaction },
+      ...options ? { options } : {},
+      ambiguousSubmit: {
+        operation: "refund-task",
+        taskId,
+        intentId
+      }
+    });
+  }
+  get walletAddress() {
+    return this.signer.publicKey.toBase58();
+  }
+  auth(descriptor) {
+    return createWalletAuthHeaders(this.signer, descriptor);
+  }
+};
+function assertNotAborted2(options, path) {
+  if (options?.signal?.aborted) {
+    throw new GibworkRequestAbortedError("POST", path, {
+      cause: options.signal.reason
+    });
+  }
+}
+
+// src/transport/http-transport.ts
+var HttpTransport = class {
+  baseUrl;
+  fetchImplementation;
+  timeoutMs;
+  constructor(options) {
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.fetchImplementation = options.fetch ?? globalThis.fetch;
+    this.timeoutMs = options.timeoutMs ?? 6e4;
+    if (typeof this.fetchImplementation !== "function") {
+      throw new GibworkConfigurationError(
+        "A fetch implementation is required in this environment"
+      );
+    }
+    if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+      throw new GibworkConfigurationError(
+        "timeoutMs must be a positive number"
+      );
+    }
+  }
+  async request(request) {
+    const controller = new AbortController();
+    const callerSignal = request.options?.signal;
+    let timedOut = false;
+    if (callerSignal?.aborted) {
+      throw new GibworkRequestAbortedError(request.method, request.path, {
+        cause: callerSignal.reason
+      });
+    }
+    const abortFromCaller = () => controller.abort(callerSignal?.reason);
+    callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, this.timeoutMs);
+    const headers = {
+      accept: "application/json",
+      ...request.headers
+    };
+    const init = {
+      method: request.method,
+      headers,
+      signal: controller.signal
+    };
+    if (request.body !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(request.body);
+    }
+    let response;
+    try {
+      response = await this.fetchImplementation(
+        `${this.baseUrl}${request.path}`,
+        init
+      );
+    } catch (cause) {
+      if (request.ambiguousSubmit) {
+        throw new GibworkAmbiguousSubmitError(
+          request.method,
+          request.path,
+          request.ambiguousSubmit,
+          { cause }
+        );
+      }
+      if (timedOut) {
+        throw new GibworkTimeoutError(
+          request.method,
+          request.path,
+          this.timeoutMs,
+          { cause }
+        );
+      }
+      if (callerSignal?.aborted) {
+        throw new GibworkRequestAbortedError(request.method, request.path, {
+          cause
+        });
+      }
+      throw new GibworkNetworkError(
+        "Could not reach the Gibwork API",
+        request.method,
+        request.path,
+        { cause }
+      );
+    } finally {
+      clearTimeout(timeout);
+      callerSignal?.removeEventListener("abort", abortFromCaller);
+    }
+    const body = await parseResponseBody(response);
+    if (!response.ok) {
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      const apiError = new GibworkApiError(
+        response.status,
+        body,
+        request.method,
+        request.path,
+        requestId
+      );
+      if (request.ambiguousSubmit && response.status >= 500) {
+        throw new GibworkAmbiguousSubmitError(
+          request.method,
+          request.path,
+          request.ambiguousSubmit,
+          { cause: apiError }
+        );
+      }
+      throw apiError;
+    }
+    return body;
+  }
+};
+function normalizeBaseUrl(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new GibworkConfigurationError("baseUrl is required");
+  }
+  let url;
+  try {
+    url = new URL(value.trim());
+  } catch (cause) {
+    throw new GibworkConfigurationError("baseUrl must be a valid URL", {
+      cause
+    });
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new GibworkConfigurationError("baseUrl must use http or https");
+  }
+  if (url.search || url.hash) {
+    throw new GibworkConfigurationError(
+      "baseUrl must not include a query string or fragment"
+    );
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+async function parseResponseBody(response) {
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/client/gibwork-client.ts
+var GibworkClient = class {
+  tasks;
+  submissions;
+  constructor(options) {
+    assertSigner(options.signer);
+    const transport = new HttpTransport({
+      baseUrl: options.baseUrl ?? DEFAULT_GIBWORK_API_URL,
+      ...options.fetch ? { fetch: options.fetch } : {},
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {}
+    });
+    this.tasks = new TasksResource(transport, options.signer);
+    this.submissions = new SubmissionsResource(transport, options.signer);
+  }
+};
+function assertSigner(signer) {
+  if (!signer || typeof signer.publicKey?.toBase58 !== "function" || typeof signer.signMessage !== "function" || typeof signer.signTransaction !== "function") {
+    throw new GibworkConfigurationError(
+      "signer must provide publicKey, signMessage, and signTransaction"
+    );
+  }
+}
+function createKeypairSigner(privateKey) {
+  const keypair = keypairFromPrivateKey(privateKey);
+  return {
+    publicKey: keypair.publicKey,
+    async signMessage(message) {
+      return nacl__default.default.sign.detached(message, keypair.secretKey);
+    },
+    async signTransaction(transaction) {
+      transaction.sign([keypair]);
+      return transaction;
+    }
+  };
+}
+function keypairFromPrivateKey(privateKey) {
+  const bytes = decodePrivateKey(privateKey);
+  try {
+    if (bytes.length === 32) return web3_js.Keypair.fromSeed(bytes);
+    if (bytes.length === 64) return web3_js.Keypair.fromSecretKey(bytes);
+  } catch {
+    throw new GibworkConfigurationError("SOLANA_PRIVATE_KEY is invalid");
+  }
+  throw new GibworkConfigurationError(
+    "SOLANA_PRIVATE_KEY must contain a 32-byte seed or 64-byte secret key"
+  );
+}
+function decodePrivateKey(privateKey) {
+  if (privateKey instanceof Uint8Array) return new Uint8Array(privateKey);
+  if (Array.isArray(privateKey)) return validateByteArray(privateKey);
+  if (typeof privateKey !== "string") {
+    throw new GibworkConfigurationError("SOLANA_PRIVATE_KEY is required");
+  }
+  const value = privateKey.trim();
+  if (!value) {
+    throw new GibworkConfigurationError("SOLANA_PRIVATE_KEY is required");
+  }
+  if (value.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(value);
+      if (!Array.isArray(parsed)) throw new Error("Expected a JSON array");
+      return validateByteArray(parsed);
+    } catch (error) {
+      if (error instanceof GibworkConfigurationError) throw error;
+      throw new GibworkConfigurationError(
+        "SOLANA_PRIVATE_KEY must be a valid JSON byte array or base58 string"
+      );
+    }
+  }
+  try {
+    return bs58__default.default.decode(value);
+  } catch {
+    throw new GibworkConfigurationError(
+      "SOLANA_PRIVATE_KEY must be a valid JSON byte array or base58 string"
+    );
+  }
+}
+function validateByteArray(values) {
+  if (!values.every(
+    (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 255
+  )) {
+    throw new GibworkConfigurationError(
+      "SOLANA_PRIVATE_KEY JSON values must be integers between 0 and 255"
+    );
+  }
+  return Uint8Array.from(values);
+}
+
+// src/node.ts
+function createGibworkClient(options) {
+  return new GibworkClient({
+    signer: createKeypairSigner(options.privateKey),
+    ...options.baseUrl !== void 0 ? { baseUrl: options.baseUrl } : {},
+    ...options.fetch ? { fetch: options.fetch } : {},
+    ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {}
+  });
+}
+
+exports.DEFAULT_GIBWORK_API_URL = DEFAULT_GIBWORK_API_URL;
+exports.GibworkAmbiguousSubmitError = GibworkAmbiguousSubmitError;
+exports.GibworkApiError = GibworkApiError;
+exports.GibworkClient = GibworkClient;
+exports.GibworkConfigurationError = GibworkConfigurationError;
+exports.GibworkError = GibworkError;
+exports.GibworkNetworkError = GibworkNetworkError;
+exports.GibworkRequestAbortedError = GibworkRequestAbortedError;
+exports.GibworkTimeoutError = GibworkTimeoutError;
+exports.createGibworkClient = createGibworkClient;
+exports.createKeypairSigner = createKeypairSigner;
+exports.keypairFromPrivateKey = keypairFromPrivateKey;
+exports.signPreparedTransaction = signPreparedTransaction;
+//# sourceMappingURL=node.cjs.map
+//# sourceMappingURL=node.cjs.map