@t-0/provider-sdk 1.1.28 → 1.1.29

package/lib/esm/index.d.ts

@@ -1,7 +1,10 @@
+export * from "./crypto/index.js";
 export * from "./client/client.js";
 export * from "./service/service.js";
 export * from "./service/validate_response.js";
+export * from "./service/validate.js";
 export * from "./service/node.js";
+export { default as NetworkHeaders } from "./common/headers.js";
 export { connectNodeAdapter as nodeAdapter } from "@connectrpc/connect-node";
 export type { Client, HandlerContext } from "@connectrpc/connect";
 export * from './common/gen/tzero/v1/common/common_pb.js';

package/lib/esm/index.js

@@ -1,7 +1,10 @@
+export * from "./crypto/index.js";
 export * from "./client/client.js";
 export * from "./service/service.js";
 export * from "./service/validate_response.js";
+export * from "./service/validate.js";
 export * from "./service/node.js";
+export { default as NetworkHeaders } from "./common/headers.js";
 export { connectNodeAdapter as nodeAdapter } from "@connectrpc/connect-node";
 export * from './common/gen/tzero/v1/common/common_pb.js';
 export * from './common/gen/tzero/v1/common/payment_method_pb.js';

package/lib/esm/service/health_pb.js

@@ -5,12 +5,15 @@
 //           buf.gen.yaml pin -- plugin and @bufbuild/protobuf runtime must
 //           agree on major).
 //
-// Regenerate by overwriting this file:
+// Regenerate with the following, which keeps this header and replaces
+// everything from the gRPC copyright line down. Do not just `mv` the generated
+// file over this one -- that would delete these instructions along with it.
 //
 //   cd node/sdk
 //   buf generate buf.build/grpc/grpc --path grpc/health/v1/health.proto \
 //     --template '{"version":"v2","plugins":[{"remote":"buf.build/bufbuild/es:v2.12.0","out":"gen-health","opt":["target=ts","import_extension=js"]}]}'
-//   mv gen-health/grpc/health/v1/health_pb.ts src/service/health_pb.ts
+//   sed '/^\/\/ Copyright 2015 The gRPC Authors/,$d' src/service/health_pb.ts > gen-health/header
+//   cat gen-health/header gen-health/grpc/health/v1/health_pb.ts > src/service/health_pb.ts
 //   rm -rf gen-health
 //
 // Vendored rather than depended on: the equivalent package

package/lib/esm/service/service.d.ts

@@ -2,11 +2,22 @@ import { ConnectRouter } from "@connectrpc/connect";
 import type { Interceptor } from "@connectrpc/connect";
 import type { DescService } from "@bufbuild/protobuf";
 import type { ServiceImpl } from "@connectrpc/connect";
+import { type Logger } from "./validate_response.js";
+export interface CreateServiceOptions {
+    /**
+     * Logger used by the SDK for error-level events (currently:
+     * response-validation failures from the interceptor safety net). The same
+     * logger will be used for any future server-wide SDK log sites.
+     *
+     * If omitted, the SDK logs to `console.error` with a JSON-encoded payload.
+     */
+    logger?: Logger;
+}
 export declare const REQUEST_VALIDITY_MILLIS = 60000;
 interface Router {
     service: <T extends DescService, I extends ServiceImpl<T>>(service: T, implementation: I) => void;
 }
-export declare const createService: (networkPublicKey: string | Buffer, registerRoutes: (router: Router) => void) => {
+export declare const createService: (networkPublicKey: string | Buffer, registerRoutes: (router: Router) => void, options?: CreateServiceOptions) => {
     routes: (router: ConnectRouter) => void;
     interceptors: Interceptor[];
     grpcWeb: boolean;

package/lib/esm/service/service.js

@@ -1,6 +1,6 @@
 import { Code, ConnectError, createContextKey, createContextValues } from "@connectrpc/connect";
 import NetworkHeaders from "../common/headers.js";
-import { secp256k1 } from '@noble/curves/secp256k1.js';
+import { verifySignature } from '../crypto/verify.js';
 import { createValidationInterceptor } from "./validate_response.js";
 import { Health } from "./health_pb.js";
 import { createHealthServiceImpl } from "./health.js";
@@ -14,29 +14,19 @@ const createSignatureVerification = (networkPublicKey) => (next) => async (req)
     if (networkPublicKey.compare(publicKey) !== 0) {
         throw new ConnectError(`${NetworkHeaders.PublicKey} value is not network public key`, Code.Unauthenticated);
     }
-    let signature = decodeHex(getHeader(req, NetworkHeaders.Signature));
-    if (signature.length === 65) {
-        signature = signature.subarray(0, 64);
-    }
+    const signature = decodeHex(getHeader(req, NetworkHeaders.Signature));
     const hasher = req.contextValues.get(kHash);
     const tsBuf = Buffer.alloc(8);
     tsBuf.writeBigUInt64LE(BigInt(ts)); // 64‑bit little‑endian timestamp
-    const hash = hasher
+    const digest = hasher
         .update(tsBuf)
         .digest();
-    let signatureValid = false;
-    try {
-        signatureValid = secp256k1.verify(signature, hash, publicKey, { prehash: false });
-    }
-    catch (e) {
-        throw new ConnectError(`${NetworkHeaders.Signature} has invalid signature or public key format: ${e}`, Code.Unauthenticated);
-    }
-    if (!signatureValid) {
+    if (!verifySignature(publicKey, digest, signature)) {
         throw new ConnectError(`${NetworkHeaders.Signature} has invalid signature`, Code.Unauthenticated);
     }
     return await next(req);
 };
-export const createService = (networkPublicKey, registerRoutes) => {
+export const createService = (networkPublicKey, registerRoutes, options) => {
     if (typeof networkPublicKey == "string") {
         networkPublicKey = decodeHex(networkPublicKey);
     }
@@ -57,7 +47,7 @@ export const createService = (networkPublicKey, registerRoutes) => {
             collected.push(Health.typeName);
             origService(Health, createHealthServiceImpl(collected));
         },
-        interceptors: [createSignatureVerification(networkPublicKey), createValidationInterceptor()],
+        interceptors: [createSignatureVerification(networkPublicKey), createValidationInterceptor(options?.logger)],
         grpcWeb: false,
         contextValues: (req) => {
             return createContextValues().set(kHash, req.hasher);

package/lib/esm/service/validate.d.ts

@@ -0,0 +1,25 @@
+import type { DescMessage, MessageShape } from "@bufbuild/protobuf";
+/**
+ * Shared protovalidate validator instance for the public {@link validate} helper.
+ * Construction is cheap, but reusing one instance avoids repeated compilation
+ * of the same rules.
+ */
+export declare const validator: import("@bufbuild/protovalidate").Validator;
+/**
+ * Validates a response message against its buf.validate proto annotations.
+ *
+ * On success, returns the message unchanged (typed). On failure, throws a
+ * {@link ConnectError} with {@link Code.Internal} and a message matching the
+ * shape emitted by the SDK's response-validation interceptor — so propagating
+ * the error from a handler produces the same wire response as not calling
+ * `validate` at all.
+ *
+ * Intended use:
+ * ```ts
+ * return validate(PayOutResponseSchema, { result: { case: "accepted", value: {} } });
+ * ```
+ *
+ * Catch the error to convert it into a domain-level failure (e.g. the `Failed`
+ * arm of a `oneof result`) instead of an opaque `Code.Internal`.
+ */
+export declare function validate<Desc extends DescMessage>(schema: Desc, msg: MessageShape<Desc>): MessageShape<Desc>;

package/lib/esm/service/validate.js

@@ -0,0 +1,38 @@
+import { Code, ConnectError } from "@connectrpc/connect";
+import { createValidator } from "@bufbuild/protovalidate";
+/**
+ * Shared protovalidate validator instance for the public {@link validate} helper.
+ * Construction is cheap, but reusing one instance avoids repeated compilation
+ * of the same rules.
+ */
+export const validator = createValidator();
+/**
+ * Validates a response message against its buf.validate proto annotations.
+ *
+ * On success, returns the message unchanged (typed). On failure, throws a
+ * {@link ConnectError} with {@link Code.Internal} and a message matching the
+ * shape emitted by the SDK's response-validation interceptor — so propagating
+ * the error from a handler produces the same wire response as not calling
+ * `validate` at all.
+ *
+ * Intended use:
+ * ```ts
+ * return validate(PayOutResponseSchema, { result: { case: "accepted", value: {} } });
+ * ```
+ *
+ * Catch the error to convert it into a domain-level failure (e.g. the `Failed`
+ * arm of a `oneof result`) instead of an opaque `Code.Internal`.
+ */
+export function validate(schema, msg) {
+    const result = validator.validate(schema, msg);
+    if (result.kind === "invalid") {
+        const details = result.violations
+            .map((v) => `${v.field?.toString() ?? ""}: ${v.message}`)
+            .join("; ");
+        throw new ConnectError(`response validation failed: ${details}`, Code.Internal);
+    }
+    if (result.kind === "error") {
+        throw new ConnectError(`response validation error: ${result.error.message}`, Code.Internal);
+    }
+    return msg;
+}

package/lib/esm/service/validate_response.d.ts

@@ -1,12 +1,26 @@
 import type { Interceptor } from "@connectrpc/connect";
+/**
+ * Minimal logger contract accepted by the SDK. Providers may pass `console`
+ * directly, or adapt their preferred logger (e.g. pino) with:
+ *
+ *   { error: (msg, fields) => pinoInstance.error(fields, msg) }
+ */
+export interface Logger {
+    error(msg: string, fields?: Record<string, unknown>): void;
+}
 /**
  * Creates a ConnectRPC interceptor that validates provider responses against
  * buf.validate proto annotations before they are serialized and sent.
  * Also validates incoming requests using the official @connectrpc/validate interceptor.
  *
  * Invalid requests return Code.InvalidArgument; invalid responses return Code.Internal.
+ *
+ * On invalid responses, a single structured `error`-level line is emitted to
+ * the supplied {@link Logger} (default: `console.error` with JSON-encoded
+ * fields) before the `Code.Internal` error is thrown. This is the safety net
+ * for handler code paths that skipped the public `validate()` helper.
  */
-export declare function createValidationInterceptor(): Interceptor;
+export declare function createValidationInterceptor(logger?: Logger): Interceptor;
 /**
  * @deprecated Use createValidationInterceptor instead.
  */

package/lib/esm/service/validate_response.js

@@ -1,15 +1,26 @@
 import { Code, ConnectError } from "@connectrpc/connect";
 import { createValidator } from "@bufbuild/protovalidate";
 import { createValidateInterceptor } from "@connectrpc/validate";
+import { SDK_VERSION } from "../version.js";
 const validator = createValidator();
+const defaultLogger = {
+    error: (msg, fields) => 
+    // eslint-disable-next-line no-console
+    console.error(JSON.stringify({ msg, ...(fields ?? {}) })),
+};
 /**
  * Creates a ConnectRPC interceptor that validates provider responses against
  * buf.validate proto annotations before they are serialized and sent.
  * Also validates incoming requests using the official @connectrpc/validate interceptor.
  *
  * Invalid requests return Code.InvalidArgument; invalid responses return Code.Internal.
+ *
+ * On invalid responses, a single structured `error`-level line is emitted to
+ * the supplied {@link Logger} (default: `console.error` with JSON-encoded
+ * fields) before the `Code.Internal` error is thrown. This is the safety net
+ * for handler code paths that skipped the public `validate()` helper.
  */
-export function createValidationInterceptor() {
+export function createValidationInterceptor(logger = defaultLogger) {
     const requestInterceptor = createValidateInterceptor();
     return (next) => async (req) => {
         // Validate request (delegates to official interceptor which throws on invalid)
@@ -19,10 +30,26 @@ export function createValidationInterceptor() {
         const msg = resp.message;
         const result = validator.validate(schema, msg);
         if (result.kind === "invalid") {
-            const details = result.violations.map(v => `${v.field?.toString() ?? ""}: ${v.message}`).join("; ");
+            const violations = result.violations.map((v) => ({
+                field: v.field?.toString() ?? "",
+                message: v.message,
+            }));
+            const details = violations.map((v) => `${v.field}: ${v.message}`).join("; ");
+            logger.error("response validation failed", {
+                rpc_method: `${req.service.typeName}/${req.method.name}`,
+                response_type: schema.typeName,
+                violations,
+                sdk_version: SDK_VERSION,
+            });
             throw new ConnectError(`response validation failed: ${details}`, Code.Internal);
         }
         if (result.kind === "error") {
+            logger.error("response validation error", {
+                rpc_method: `${req.service.typeName}/${req.method.name}`,
+                response_type: schema.typeName,
+                error: result.error.message,
+                sdk_version: SDK_VERSION,
+            });
             throw new ConnectError(`response validation error: ${result.error.message}`, Code.Internal);
         }
         return resp;

package/lib/esm/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "1.1.28";
+export declare const SDK_VERSION = "1.1.29";

package/lib/esm/version.js

@@ -1,3 +1,3 @@
 // SDK semantic version. Bumped in lockstep with all other SDKs by the
 // release.yaml workflow.
-export const SDK_VERSION = "1.1.28";
+export const SDK_VERSION = "1.1.29";