@reallyme/codec 0.1.20 → 0.1.22

package/dist/protoProcess.js

@@ -0,0 +1,282 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { MAX_CODEC_PROTO_JSON_BYTES, MAX_CODEC_PROTO_MESSAGE_BYTES, requireBoundaryAggregate, utf8ByteLength, } from "./boundary.js";
+import { ReallyMeCodecError } from "./errors.js";
+import { CodecBoundaryErrorSchema, CodecErrorReason, CodecErrorSchema, CodecOperationRequestSchema, CodecProtoResultEnvelopeSchema, CodecProtoResultStatus, } from "./proto/generated/reallyme/codec/v1/codec_pb.js";
+import { ensureBytesInput, readIndependentBoundedBytesOutput, } from "./readOutput.js";
+import { requireReallyMeCodecWasmProvider } from "./wasmProvider.js";
+const MAX_CODEC_PROTO_RESULT_ENVELOPE_BYTES = 1_048_592;
+const PROTO_REQUEST_OVERHEAD_BUDGET = 64;
+const requireProtoBytes = (value) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    return value.length;
+};
+const requireProtoString = (value) => {
+    if (typeof value !== "string") {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    return value;
+};
+const protoUtf8Length = (value) => {
+    const text = requireProtoString(value);
+    try {
+        return utf8ByteLength(text);
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            return undefined;
+        }
+        throw error;
+    }
+};
+const validateGeneratedProtoRequest = (request) => {
+    const lengths = [PROTO_REQUEST_OVERHEAD_BUDGET];
+    switch (request.operation.case) {
+        case undefined:
+        case "multicodecTable":
+            break;
+        case "multicodecPrefixForName":
+            {
+                const length = protoUtf8Length(request.operation.value.name);
+                if (length === undefined) {
+                    return false;
+                }
+                lengths.push(length);
+            }
+            break;
+        case "multicodecLookupPrefix":
+            lengths.push(requireProtoBytes(request.operation.value.value));
+            break;
+        case "multikeyParse":
+            {
+                const length = protoUtf8Length(request.operation.value.multikey);
+                if (length === undefined) {
+                    return false;
+                }
+                lengths.push(length);
+            }
+            break;
+        case "dagCborVerifyCid":
+            {
+                const length = protoUtf8Length(request.operation.value.cid);
+                if (length === undefined) {
+                    return false;
+                }
+                lengths.push(length);
+            }
+            lengths.push(requireProtoBytes(request.operation.value.payload));
+            break;
+        case "pemDecode": {
+            lengths.push(requireProtoBytes(request.operation.value.pem));
+            const options = request.operation.value.options;
+            if (options !== undefined) {
+                if (!Array.isArray(options.allowedLabels)) {
+                    throw new ReallyMeCodecError("invalid-input");
+                }
+                if (options.allowedLabels.length > MAX_CODEC_PROTO_MESSAGE_BYTES / 5) {
+                    return false;
+                }
+                lengths.push(options.allowedLabels.length * 5);
+            }
+            break;
+        }
+        default:
+            throw new ReallyMeCodecError("invalid-input");
+    }
+    try {
+        requireBoundaryAggregate(lengths, MAX_CODEC_PROTO_MESSAGE_BYTES);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            return false;
+        }
+        throw error;
+    }
+};
+const boundaryResourceLimitResult = () => {
+    try {
+        return {
+            status: "codec-error",
+            bytes: toBinary(CodecErrorSchema, create(CodecErrorSchema, {
+                error: {
+                    case: "boundary",
+                    value: create(CodecBoundaryErrorSchema, {
+                        reason: CodecErrorReason.BOUNDARY_RESOURCE_LIMIT_EXCEEDED,
+                    }),
+                },
+            })),
+            isCodecError: true,
+        };
+    }
+    catch (_error) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+};
+const boundaryResourceLimitEnvelope = () => {
+    const result = boundaryResourceLimitResult();
+    try {
+        return toBinary(CodecProtoResultEnvelopeSchema, create(CodecProtoResultEnvelopeSchema, {
+            status: CodecProtoResultStatus.CODEC_ERROR,
+            payload: result.bytes,
+        }));
+    }
+    catch (_error) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    finally {
+        result.bytes.fill(0);
+    }
+};
+const decodeResultEnvelope = (envelopeBytes) => {
+    try {
+        const envelope = fromBinary(CodecProtoResultEnvelopeSchema, envelopeBytes);
+        try {
+            switch (envelope.status) {
+                case CodecProtoResultStatus.RESULT:
+                    return {
+                        status: "result",
+                        bytes: envelope.payload.slice(),
+                        isCodecError: false,
+                    };
+                case CodecProtoResultStatus.CODEC_ERROR:
+                    return {
+                        status: "codec-error",
+                        bytes: envelope.payload.slice(),
+                        isCodecError: true,
+                    };
+                case CodecProtoResultStatus.UNSPECIFIED:
+                    throw new ReallyMeCodecError("provider-failure");
+            }
+        }
+        finally {
+            envelope.payload.fill(0);
+        }
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            throw error;
+        }
+        throw new ReallyMeCodecError("provider-failure");
+    }
+};
+/**
+ * Execute one binary generated-protobuf request.
+ *
+ * The returned bytes are always a `CodecProtoResultEnvelope`; malformed or
+ * unsupported requests are represented inside that envelope.
+ */
+export const processProto = (requestBytes) => {
+    ensureBytesInput(requestBytes);
+    if (requestBytes.length > MAX_CODEC_PROTO_MESSAGE_BYTES) {
+        return boundaryResourceLimitEnvelope();
+    }
+    return readIndependentBoundedBytesOutput(requireReallyMeCodecWasmProvider().processProto(requestBytes), requestBytes, MAX_CODEC_PROTO_RESULT_ENVELOPE_BYTES);
+};
+/**
+ * Execute one generated ProtoJSON request and return the same binary envelope
+ * used by `processProto`.
+ */
+export const processProtoJson = (requestJson) => {
+    ensureBytesInput(requestJson);
+    if (requestJson.length > MAX_CODEC_PROTO_JSON_BYTES) {
+        return boundaryResourceLimitEnvelope();
+    }
+    return readIndependentBoundedBytesOutput(requireReallyMeCodecWasmProvider().processProtoJson(requestJson), requestJson, MAX_CODEC_PROTO_RESULT_ENVELOPE_BYTES);
+};
+export const processGeneratedProtoRequest = (request) => {
+    let withinBoundary;
+    try {
+        withinBoundary = validateGeneratedProtoRequest(request);
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            throw error;
+        }
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    if (!withinBoundary) {
+        return boundaryResourceLimitResult();
+    }
+    let requestBytes;
+    try {
+        requestBytes = toBinary(CodecOperationRequestSchema, request);
+    }
+    catch (_error) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    try {
+        if (requestBytes.length > MAX_CODEC_PROTO_MESSAGE_BYTES) {
+            throw new ReallyMeCodecError("invalid-input");
+        }
+        const envelopeBytes = processProto(requestBytes);
+        try {
+            return decodeResultEnvelope(envelopeBytes);
+        }
+        finally {
+            envelopeBytes.fill(0);
+        }
+    }
+    finally {
+        requestBytes.fill(0);
+    }
+};
+const errorCodeForCodecError = (bytes) => {
+    let error;
+    try {
+        error = fromBinary(CodecErrorSchema, bytes);
+    }
+    catch (_error) {
+        return "provider-failure";
+    }
+    const reason = error.error.value?.reason;
+    const reasonIsKnown = reason !== undefined &&
+        Object.values(CodecErrorReason).some((candidate) => candidate === reason);
+    if (!reasonIsKnown) {
+        return "provider-failure";
+    }
+    switch (error.error.case) {
+        case "baseEncoding":
+            return reason >= 100 && reason <= 199
+                ? "invalid-input"
+                : "provider-failure";
+        case "pem":
+            return reason >= 200 && reason <= 299
+                ? "invalid-input"
+                : "provider-failure";
+        case "multiformat":
+            return reason >= 300 && reason <= 399
+                ? "invalid-input"
+                : "provider-failure";
+        case "canonicalization":
+            if (reason === CodecErrorReason.CANONICAL_INTERNAL) {
+                return "provider-failure";
+            }
+            return reason >= 400 && reason <= 499
+                ? "invalid-input"
+                : "provider-failure";
+        case "backend":
+            return "provider-failure";
+        case "boundary":
+            // This is the only boundary error the generated facade creates from
+            // caller input. Malformed/missing generated requests indicate provider
+            // corruption or skew, not bad input supplied to the high-level API.
+            return reason === CodecErrorReason.BOUNDARY_RESOURCE_LIMIT_EXCEEDED
+                ? "invalid-input"
+                : "provider-failure";
+        case undefined:
+            return "provider-failure";
+    }
+};
+export const protoPayloadOrThrow = (result) => {
+    if (result.isCodecError) {
+        const code = errorCodeForCodecError(result.bytes);
+        result.bytes.fill(0);
+        throw new ReallyMeCodecError(code);
+    }
+    return result.bytes;
+};

package/dist/readOutput.d.ts

@@ -3,6 +3,7 @@ export declare const ensureStringInput: (value: string) => void;
 export declare const ensureStringValue: (value: string) => void;
 export declare const readBooleanOutput: (value: unknown) => boolean;
 export declare const readBytesOutput: (value: unknown) => Uint8Array;
+export declare const readIndependentBoundedBytesOutput: (value: unknown, input: Uint8Array, maximumLength: number) => Uint8Array;
 export declare const readNumberOutput: (value: unknown) => number;
 export declare const readObjectOutput: (value: unknown) => object;
 export declare const readStringOutput: (value: unknown) => string;
@@ -16,6 +17,5 @@ export type ReallyMeCodecProtoResult = Readonly<{
     bytes: Uint8Array;
     isCodecError: boolean;
 }>;
-export declare const readProtoResultOutput: (value: unknown) => ReallyMeCodecProtoResult;
 export declare const readOptionalLengthProperty: (object: object, name: string) => number | undefined;
 export declare const asciiBytesToString: (bytes: Uint8Array) => string;

package/dist/readOutput.js

@@ -1,7 +1,38 @@
 // SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
 //
 // SPDX-License-Identifier: Apache-2.0
+import { MAX_CODEC_FFI_INPUT_BYTES, MAX_CODEC_FFI_OUTPUT_BYTES, requireBoundaryUtf8String, } from "./boundary.js";
 import { ReallyMeCodecError } from "./errors.js";
+const readProviderProperty = (object, name, allowMissing = false) => {
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(object, name);
+        if (descriptor === undefined) {
+            if (allowMissing) {
+                return undefined;
+            }
+            throw new ReallyMeCodecError("provider-failure");
+        }
+        if (!("value" in descriptor)) {
+            throw new ReallyMeCodecError("provider-failure");
+        }
+        return descriptor.value;
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            throw error;
+        }
+        throw new ReallyMeCodecError("provider-failure");
+    }
+};
+const requireBoundedProviderString = (value, allowEmpty) => {
+    try {
+        requireBoundaryUtf8String(value, allowEmpty, MAX_CODEC_FFI_OUTPUT_BYTES);
+        return value;
+    }
+    catch (_error) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+};
 export const ensureBytesInput = (value) => {
     if (!(value instanceof Uint8Array)) {
         throw new ReallyMeCodecError("invalid-input");
@@ -27,6 +58,25 @@ export const readBytesOutput = (value) => {
     if (!(value instanceof Uint8Array)) {
         throw new ReallyMeCodecError("provider-failure");
     }
+    if (value.length > MAX_CODEC_FFI_OUTPUT_BYTES) {
+        value.fill(0);
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    return value;
+};
+export const readIndependentBoundedBytesOutput = (value, input, maximumLength) => {
+    if (!(value instanceof Uint8Array)) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    // Even non-overlapping views into one ArrayBuffer share transfer and detach
+    // semantics, so they do not provide independent result ownership.
+    if (value.buffer === input.buffer) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    if (value.length === 0 || value.length > maximumLength) {
+        value.fill(0);
+        throw new ReallyMeCodecError("provider-failure");
+    }
     return value;
 };
 export const readNumberOutput = (value) => {
@@ -39,56 +89,60 @@ export const readObjectOutput = (value) => {
     if (typeof value !== "object" || value === null) {
         throw new ReallyMeCodecError("provider-failure");
     }
-    return value;
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new ReallyMeCodecError("provider-failure");
+        }
+        return value;
+    }
+    catch (error) {
+        if (error instanceof ReallyMeCodecError) {
+            throw error;
+        }
+        throw new ReallyMeCodecError("provider-failure");
+    }
 };
 export const readStringOutput = (value) => {
     if (typeof value !== "string") {
         throw new ReallyMeCodecError("provider-failure");
     }
-    return value;
+    return requireBoundedProviderString(value, true);
 };
 export const readStringProperty = (object, name) => {
-    const value = Reflect.get(object, name);
+    const value = readProviderProperty(object, name);
     if (typeof value !== "string" || value.length === 0) {
         throw new ReallyMeCodecError("provider-failure");
     }
-    return value;
+    return requireBoundedProviderString(value, false);
 };
 export const readStringValueProperty = (object, name) => {
-    const value = Reflect.get(object, name);
+    const value = readProviderProperty(object, name);
     if (typeof value !== "string") {
         throw new ReallyMeCodecError("provider-failure");
     }
-    return value;
+    return requireBoundedProviderString(value, true);
 };
 export const readBooleanProperty = (object, name) => {
-    const value = Reflect.get(object, name);
+    const value = readProviderProperty(object, name);
     if (typeof value !== "boolean") {
         throw new ReallyMeCodecError("provider-failure");
     }
     return value;
 };
 export const readBytesProperty = (object, name) => {
-    const value = Reflect.get(object, name);
+    const value = readProviderProperty(object, name);
     if (!(value instanceof Uint8Array)) {
         throw new ReallyMeCodecError("provider-failure");
     }
-    return value;
-};
-export const readProtoResultOutput = (value) => {
-    const object = readObjectOutput(value);
-    const status = readStringProperty(object, "status");
-    if (status !== "result" && status !== "codec-error") {
+    if (value.length > MAX_CODEC_FFI_OUTPUT_BYTES) {
+        value.fill(0);
         throw new ReallyMeCodecError("provider-failure");
     }
-    return {
-        status,
-        bytes: readBytesProperty(object, "bytes"),
-        isCodecError: status === "codec-error",
-    };
+    return value;
 };
 export const readOptionalLengthProperty = (object, name) => {
-    const value = Reflect.get(object, name);
+    const value = readProviderProperty(object, name, true);
     if (value === undefined) {
         return undefined;
     }
@@ -98,8 +152,17 @@ export const readOptionalLengthProperty = (object, name) => {
     return value;
 };
 export const asciiBytesToString = (bytes) => {
+    if (bytes.length > MAX_CODEC_FFI_INPUT_BYTES) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
     let value = "";
-    for (const byte of bytes) {
+    // Indexed access avoids executing an attacker-supplied iterator installed
+    // on an otherwise valid Uint8Array instance.
+    for (let index = 0; index < bytes.length; index += 1) {
+        const byte = bytes[index];
+        if (byte === undefined) {
+            throw new ReallyMeCodecError("invalid-input");
+        }
         if (byte > 0x7f) {
             throw new ReallyMeCodecError("invalid-input");
         }

package/dist/wasm/reallyme_codec_wasm.d.ts

@@ -81,16 +81,6 @@ export function dagCborSha256ContentHash(bytes: Uint8Array): Uint8Array;
  */
 export function dagCborVerifyCid(cid: string, bytes: Uint8Array): any;
 
-/**
- * Recompute and compare a CID as a `CodecDagCborVerifyCidResult` protobuf message.
- */
-export function dagCborVerifyCidProto(cid: string, bytes: Uint8Array): Uint8Array;
-
-/**
- * Recompute and compare a CID protobuf message with an explicit result status.
- */
-export function dagCborVerifyCidProtoResult(cid: string, bytes: Uint8Array): any;
-
 /**
  * Return whether a string parses as a CID.
  */
@@ -121,31 +111,11 @@ export function multibaseDecode(encoded: string): Uint8Array;
  */
 export function multicodecLookupPrefix(bytes: Uint8Array): any;
 
-/**
- * Resolve a prefix as a `CodecMulticodecLookupResult` protobuf message.
- */
-export function multicodecLookupPrefixProto(bytes: Uint8Array): Uint8Array;
-
-/**
- * Resolve a prefix protobuf message with an explicit result status.
- */
-export function multicodecLookupPrefixProtoResult(bytes: Uint8Array): any;
-
 /**
  * Return multicodec metadata for a canonical codec name.
  */
 export function multicodecPrefixForName(codec_name: string): any;
 
-/**
- * Return multicodec metadata as a `CodecMulticodecSpec` protobuf message.
- */
-export function multicodecPrefixForNameProto(codec_name: string): Uint8Array;
-
-/**
- * Return multicodec metadata protobuf bytes with an explicit result status.
- */
-export function multicodecPrefixForNameProtoResult(codec_name: string): any;
-
 /**
  * Strip a known multicodec prefix, or return the original bytes when none is found.
  */
@@ -156,16 +126,6 @@ export function multicodecStripPrefix(bytes: Uint8Array): Uint8Array;
  */
 export function multicodecTable(): any;
 
-/**
- * Return the supported multicodec table as protobuf bytes.
- */
-export function multicodecTableProto(): Uint8Array;
-
-/**
- * Return the supported multicodec table protobuf bytes with an explicit result status.
- */
-export function multicodecTableProtoResult(): any;
-
 /**
  * Encode a public key as a multibase base58btc multikey.
  */
@@ -177,34 +137,24 @@ export function multikeyEncode(codec_name: string, public_key: Uint8Array): stri
 export function multikeyParse(multikey: string): any;
 
 /**
- * Parse and validate a multikey as a `CodecMultikeyParseResult` protobuf message.
+ * Decode PEM armor bytes with caller-supplied size and label policy.
  */
-export function multikeyParseProto(multikey: string): Uint8Array;
+export function pemDecode(input: Uint8Array, options_json: string): any;
 
 /**
- * Parse and validate a multikey protobuf message with an explicit result status.
+ * Encode DER bytes as wipeable PEM armor bytes.
  */
-export function multikeyParseProtoResult(multikey: string): any;
+export function pemEncode(label: string, der: Uint8Array, options_json: string): Uint8Array;
 
 /**
- * Decode PEM text armor with caller-supplied size and label policy.
+ * Execute one generated binary protobuf request and return a binary result envelope.
  */
-export function pemDecode(input: string, options_json: string): any;
+export function processProto(request: Uint8Array): Uint8Array;
 
 /**
- * Decode PEM text armor as a `CodecPemDecodeResult` protobuf message.
+ * Execute one generated ProtoJSON request and return a binary result envelope.
  */
-export function pemDecodeProto(input: string, options_json: string): Uint8Array;
-
-/**
- * Decode PEM text armor protobuf bytes with an explicit result status.
- */
-export function pemDecodeProtoResult(input: string, options_json: string): any;
-
-/**
- * Encode DER bytes as PEM text armor.
- */
-export function pemEncode(label: string, der: Uint8Array, options_json: string): string;
+export function processProtoJson(request_json: Uint8Array): Uint8Array;
 
 /**
  * Fail closed when a codec name is not in the supported table.
@@ -225,55 +175,45 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly base58btcDecode: (a: number, b: number) => [number, number, number];
+    readonly base58btcDecode: (a: any) => [number, number, number];
     readonly base58btcEncode: (a: any) => [number, number, number, number];
-    readonly base64Decode: (a: number, b: number) => [number, number, number];
-    readonly base64Encode: (a: any) => [number, number];
-    readonly base64urlDecode: (a: number, b: number) => [number, number, number];
-    readonly base64urlEncode: (a: any) => [number, number];
-    readonly bindingTypeMatchesCodec: (a: number, b: number, c: number, d: number) => number;
-    readonly bytesToLowerHex: (a: any) => [number, number];
-    readonly canonicalizeJson: (a: number, b: number) => [number, number, number, number];
+    readonly base64Decode: (a: any) => [number, number, number];
+    readonly base64Encode: (a: any) => [number, number, number, number];
+    readonly base64urlDecode: (a: any) => [number, number, number];
+    readonly base64urlEncode: (a: any) => [number, number, number, number];
+    readonly bindingTypeMatchesCodec: (a: any, b: any) => [number, number, number];
+    readonly bytesToLowerHex: (a: any) => [number, number, number, number];
+    readonly canonicalizeJson: (a: any) => [number, number, number, number];
     readonly dagCborCodecCode: () => number;
     readonly dagCborComputeCid: (a: any) => [number, number, number, number];
     readonly dagCborDecode: (a: any) => [number, number, number, number];
-    readonly dagCborEncode: (a: number, b: number) => [number, number, number];
+    readonly dagCborEncode: (a: any) => [number, number, number];
     readonly dagCborMultihash: (a: any) => [number, number, number];
     readonly dagCborSha256ContentHash: (a: any) => [number, number, number];
-    readonly dagCborVerifyCid: (a: number, b: number, c: any) => [number, number, number];
-    readonly dagCborVerifyCidProto: (a: number, b: number, c: any) => [number, number, number];
-    readonly dagCborVerifyCidProtoResult: (a: number, b: number, c: any) => [number, number, number];
-    readonly isValidCidString: (a: number, b: number) => number;
-    readonly lowerHexToBytes: (a: number, b: number) => [number, number, number];
+    readonly dagCborVerifyCid: (a: any, b: any) => [number, number, number];
+    readonly isValidCidString: (a: any) => [number, number, number];
+    readonly lowerHexToBytes: (a: any) => [number, number, number];
     readonly multibaseBase58btcEncode: (a: any) => [number, number, number, number];
-    readonly multibaseBase64urlEncode: (a: any) => [number, number];
-    readonly multibaseDecode: (a: number, b: number) => [number, number, number];
+    readonly multibaseBase64urlEncode: (a: any) => [number, number, number, number];
+    readonly multibaseDecode: (a: any) => [number, number, number];
     readonly multicodecLookupPrefix: (a: any) => [number, number, number];
-    readonly multicodecLookupPrefixProto: (a: any) => [number, number, number];
-    readonly multicodecLookupPrefixProtoResult: (a: any) => [number, number, number];
-    readonly multicodecPrefixForName: (a: number, b: number) => [number, number, number];
-    readonly multicodecPrefixForNameProto: (a: number, b: number) => [number, number, number];
-    readonly multicodecPrefixForNameProtoResult: (a: number, b: number) => [number, number, number];
-    readonly multicodecStripPrefix: (a: any) => any;
+    readonly multicodecPrefixForName: (a: any) => [number, number, number];
+    readonly multicodecStripPrefix: (a: any) => [number, number, number];
     readonly multicodecTable: () => [number, number, number];
-    readonly multicodecTableProto: () => [number, number, number];
-    readonly multicodecTableProtoResult: () => [number, number, number];
-    readonly multikeyEncode: (a: number, b: number, c: any) => [number, number, number, number];
-    readonly multikeyParse: (a: number, b: number) => [number, number, number];
-    readonly multikeyParseProto: (a: number, b: number) => [number, number, number];
-    readonly multikeyParseProtoResult: (a: number, b: number) => [number, number, number];
-    readonly pemDecode: (a: number, b: number, c: number, d: number) => [number, number, number];
-    readonly pemDecodeProto: (a: number, b: number, c: number, d: number) => [number, number, number];
-    readonly pemDecodeProtoResult: (a: number, b: number, c: number, d: number) => [number, number, number];
-    readonly pemEncode: (a: number, b: number, c: any, d: number, e: number) => [number, number, number, number];
-    readonly requireSupportedMulticodec: (a: number, b: number) => [number, number];
-    readonly tryParseCid: (a: number, b: number) => any;
-    readonly validateKeyBinding: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly multikeyEncode: (a: any, b: any) => [number, number, number, number];
+    readonly multikeyParse: (a: any) => [number, number, number];
+    readonly pemDecode: (a: any, b: any) => [number, number, number];
+    readonly pemEncode: (a: any, b: any, c: any) => [number, number, number];
+    readonly processProto: (a: any) => [number, number, number];
+    readonly processProtoJson: (a: any) => [number, number, number];
+    readonly requireSupportedMulticodec: (a: any) => [number, number];
+    readonly tryParseCid: (a: any) => [number, number, number];
+    readonly validateKeyBinding: (a: any, b: number, c: any) => [number, number];
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;
     readonly __externref_table_alloc: () => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
-    readonly __wbindgen_malloc: (a: number, b: number) => number;
-    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __wbindgen_start: () => void;