@hashgraphonline/standards-sdk 0.1.165 → 0.1.166

package/dist/browser/hcs-12/validation/schemas.d.ts

@@ -0,0 +1,361 @@
+import { z } from 'zod';
+/**
+ * Action registration schema - follows HCS-12 spec exactly
+ */
+export declare const actionRegistrationSchema: z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+    op: z.ZodLiteral<"register">;
+    t_id: z.ZodString;
+    hash: z.ZodString;
+    wasm_hash: z.ZodString;
+    js_t_id: z.ZodOptional<z.ZodString>;
+    js_hash: z.ZodOptional<z.ZodString>;
+    interface_version: z.ZodOptional<z.ZodString>;
+    info_t_id: z.ZodOptional<z.ZodString>;
+    source_verification: z.ZodOptional<z.ZodObject<{
+        source_t_id: z.ZodString;
+        source_hash: z.ZodString;
+        compiler_version: z.ZodString;
+        cargo_version: z.ZodString;
+        target: z.ZodLiteral<"wasm32-unknown-unknown">;
+        profile: z.ZodString;
+        build_flags: z.ZodArray<z.ZodString, "many">;
+        lockfile_hash: z.ZodString;
+        source_structure: z.ZodObject<{
+            format: z.ZodEnum<["tar.gz", "zip", "car"]>;
+            root_manifest: z.ZodString;
+            includes_lockfile: z.ZodBoolean;
+            workspace_members: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            format?: "tar.gz" | "zip" | "car";
+            root_manifest?: string;
+            includes_lockfile?: boolean;
+            workspace_members?: string[];
+        }, {
+            format?: "tar.gz" | "zip" | "car";
+            root_manifest?: string;
+            includes_lockfile?: boolean;
+            workspace_members?: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        profile?: string;
+        target?: "wasm32-unknown-unknown";
+        source_t_id?: string;
+        source_hash?: string;
+        compiler_version?: string;
+        cargo_version?: string;
+        build_flags?: string[];
+        lockfile_hash?: string;
+        source_structure?: {
+            format?: "tar.gz" | "zip" | "car";
+            root_manifest?: string;
+            includes_lockfile?: boolean;
+            workspace_members?: string[];
+        };
+    }, {
+        profile?: string;
+        target?: "wasm32-unknown-unknown";
+        source_t_id?: string;
+        source_hash?: string;
+        compiler_version?: string;
+        cargo_version?: string;
+        build_flags?: string[];
+        lockfile_hash?: string;
+        source_structure?: {
+            format?: "tar.gz" | "zip" | "car";
+            root_manifest?: string;
+            includes_lockfile?: boolean;
+            workspace_members?: string[];
+        };
+    }>>;
+    previous_version: z.ZodOptional<z.ZodString>;
+    migration_notes: z.ZodOptional<z.ZodString>;
+    validation_rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<any, z.ZodTypeDef, any>>>;
+    m: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    p?: "hcs-12";
+    op?: "register";
+    m?: string;
+    t_id?: string;
+    hash?: string;
+    wasm_hash?: string;
+    js_t_id?: string;
+    js_hash?: string;
+    interface_version?: string;
+    info_t_id?: string;
+    source_verification?: {
+        profile?: string;
+        target?: "wasm32-unknown-unknown";
+        source_t_id?: string;
+        source_hash?: string;
+        compiler_version?: string;
+        cargo_version?: string;
+        build_flags?: string[];
+        lockfile_hash?: string;
+        source_structure?: {
+            format?: "tar.gz" | "zip" | "car";
+            root_manifest?: string;
+            includes_lockfile?: boolean;
+            workspace_members?: string[];
+        };
+    };
+    previous_version?: string;
+    migration_notes?: string;
+    validation_rules?: Record<string, any>;
+}, {
+    p?: "hcs-12";
+    op?: "register";
+    m?: string;
+    t_id?: string;
+    hash?: string;
+    wasm_hash?: string;
+    js_t_id?: string;
+    js_hash?: string;
+    interface_version?: string;
+    info_t_id?: string;
+    source_verification?: {
+        profile?: string;
+        target?: "wasm32-unknown-unknown";
+        source_t_id?: string;
+        source_hash?: string;
+        compiler_version?: string;
+        cargo_version?: string;
+        build_flags?: string[];
+        lockfile_hash?: string;
+        source_structure?: {
+            format?: "tar.gz" | "zip" | "car";
+            root_manifest?: string;
+            includes_lockfile?: boolean;
+            workspace_members?: string[];
+        };
+    };
+    previous_version?: string;
+    migration_notes?: string;
+    validation_rules?: Record<string, any>;
+}>;
+/**
+ * Block registration schema - follows HCS-12 spec exactly
+ */
+export declare const blockRegistrationSchema: z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+    op: z.ZodEnum<["register", "template"]>;
+    name: z.ZodString;
+    version: z.ZodString;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodAny, z.ZodString]>>;
+    t_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    data?: any;
+    p?: "hcs-12";
+    op?: "register" | "template";
+    t_id?: string;
+    version?: string;
+}, {
+    name?: string;
+    data?: any;
+    p?: "hcs-12";
+    op?: "register" | "template";
+    t_id?: string;
+    version?: string;
+}>;
+/**
+ * Assembly message schema - union of all operation types
+ */
+export declare const assemblyMessageSchema: z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+} & {
+    op: z.ZodLiteral<"register">;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    author: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    p?: "hcs-12";
+    op?: "register";
+    version?: string;
+    description?: string;
+    tags?: string[];
+    author?: string;
+}, {
+    name?: string;
+    p?: "hcs-12";
+    op?: "register";
+    version?: string;
+    description?: string;
+    tags?: string[];
+    author?: string;
+}>, z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+} & {
+    op: z.ZodLiteral<"add-action">;
+    t_id: z.ZodString;
+    alias: z.ZodString;
+    config: z.ZodOptional<z.ZodAny>;
+    data: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    data?: string;
+    p?: "hcs-12";
+    op?: "add-action";
+    t_id?: string;
+    alias?: string;
+    config?: any;
+}, {
+    data?: string;
+    p?: "hcs-12";
+    op?: "add-action";
+    t_id?: string;
+    alias?: string;
+    config?: any;
+}>, z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+} & {
+    op: z.ZodLiteral<"add-block">;
+    block_t_id: z.ZodString;
+    actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    data: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    data?: string;
+    p?: "hcs-12";
+    op?: "add-block";
+    attributes?: Record<string, any>;
+    actions?: Record<string, string>;
+    block_t_id?: string;
+    children?: string[];
+}, {
+    data?: string;
+    p?: "hcs-12";
+    op?: "add-block";
+    attributes?: Record<string, any>;
+    actions?: Record<string, string>;
+    block_t_id?: string;
+    children?: string[];
+}>, z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+} & {
+    op: z.ZodLiteral<"update">;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    p?: "hcs-12";
+    op?: "update";
+    description?: string;
+    tags?: string[];
+}, {
+    p?: "hcs-12";
+    op?: "update";
+    description?: string;
+    tags?: string[];
+}>]>;
+/**
+ * Legacy assembly registration schema for backwards compatibility
+ */
+export declare const assemblyRegistrationSchema: z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+} & {
+    op: z.ZodLiteral<"register">;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    author: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    p?: "hcs-12";
+    op?: "register";
+    version?: string;
+    description?: string;
+    tags?: string[];
+    author?: string;
+}, {
+    name?: string;
+    p?: "hcs-12";
+    op?: "register";
+    version?: string;
+    description?: string;
+    tags?: string[];
+    author?: string;
+}>;
+/**
+ * HashLinks registration schema - for global directory
+ */
+export declare const hashLinksRegistrationSchema: z.ZodObject<{
+    p: z.ZodLiteral<"hcs-12">;
+} & {
+    op: z.ZodLiteral<"register">;
+    t_id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    category: z.ZodOptional<z.ZodString>;
+    featured: z.ZodOptional<z.ZodBoolean>;
+    icon: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    website: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    p?: "hcs-12";
+    op?: "register";
+    t_id?: string;
+    website?: string;
+    description?: string;
+    tags?: string[];
+    category?: string;
+    author?: string;
+    featured?: boolean;
+    icon?: string;
+}, {
+    name?: string;
+    p?: "hcs-12";
+    op?: "register";
+    t_id?: string;
+    website?: string;
+    description?: string;
+    tags?: string[];
+    category?: string;
+    author?: string;
+    featured?: boolean;
+    icon?: string;
+}>;
+/**
+ * Validate action registration
+ */
+export declare function validateActionRegistration(data: unknown): z.infer<typeof actionRegistrationSchema>;
+/**
+ * Validate block registration
+ */
+export declare function validateBlockRegistration(data: unknown): z.infer<typeof blockRegistrationSchema>;
+/**
+ * Validate assembly message (any operation type)
+ */
+export declare function validateAssemblyMessage(data: unknown): z.infer<typeof assemblyMessageSchema>;
+/**
+ * Validate assembly registration
+ */
+export declare function validateAssemblyRegistration(data: unknown): z.infer<typeof assemblyRegistrationSchema>;
+/**
+ * Validate HashLinks registration
+ */
+export declare function validateHashLinksRegistration(data: unknown): z.infer<typeof hashLinksRegistrationSchema>;
+/**
+ * Type-safe validation with error details
+ */
+export declare function safeValidate<T>(schema: z.ZodSchema<T>, data: unknown): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    errors: z.ZodError;
+};
+/**
+ * Validate data against a schema and return validation result
+ */
+export declare function validateWithSchema<T>(data: unknown, schema: z.ZodSchema<T>): {
+    isValid: boolean;
+    errors: string[];
+    data?: T;
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/browser/hcs-12/validation/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/hcs-12/validation/schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyGxB;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAC;AA0EH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;EAAyB,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EActC,CAAC;AAEH;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,OAAO,GACZ,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAE1C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,OAAO,GACZ,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAEzC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,GACZ,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAEvC;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,OAAO,GACZ,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAE5C;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,OAAO,GACZ,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAE7C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,OAAO,GACZ;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAA;CAAE,CAMrE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAA;CAAE,CASlD"}

package/dist/browser/hcs-12/validation/wasm-validator.d.ts

@@ -0,0 +1,81 @@
+import { Logger } from '../../utils/logger';
+import { ModuleInfo } from '../types';
+export interface WasmValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    version?: number;
+    exports?: string[];
+    imports?: ImportInfo[];
+    memoryRequirements?: MemoryRequirements;
+    exportSignatures?: Record<string, ExportSignature>;
+    moduleInfo?: ModuleInfo;
+}
+export interface ImportInfo {
+    module: string;
+    name: string;
+    type: string;
+}
+export interface MemoryRequirements {
+    initial: number;
+    maximum?: number;
+}
+export interface ExportSignature {
+    type: string;
+    params: string[];
+    results: string[];
+}
+/**
+ * Validator for WASM modules
+ */
+export declare class WasmValidator {
+    private logger;
+    private cryptoAdapter;
+    private readonly REQUIRED_EXPORTS;
+    private readonly ALLOWED_IMPORTS;
+    private readonly MAX_INITIAL_MEMORY;
+    private readonly WARN_MODULE_SIZE;
+    private readonly MAX_MODULE_SIZE;
+    constructor(logger: Logger);
+    /**
+     * Validate a WASM module
+     */
+    validate(wasmData: Uint8Array): Promise<WasmValidationResult>;
+    /**
+     * Validate INFO function return
+     */
+    validateInfoFunction(infoFunc: () => Promise<string> | string): Promise<WasmValidationResult>;
+    /**
+     * Validate action parameter schemas
+     */
+    validateActionSchemas(moduleInfo: any): Promise<WasmValidationResult>;
+    /**
+     * Extract metadata from WASM
+     */
+    extractMetadata(wasmData: Uint8Array): Promise<any>;
+    /**
+     * Calculate WASM hash
+     */
+    calculateHash(wasmData: Uint8Array): Promise<string>;
+    /**
+     * Create SSR-safe hash for WASM data
+     */
+    private createSSRSafeHash;
+    /**
+     * Validate WASM magic number
+     */
+    private validateMagicNumber;
+    /**
+     * Get WASM version
+     */
+    private getWasmVersion;
+    /**
+     * Parse WASM module (simplified for testing)
+     */
+    private parseModule;
+    /**
+     * Check for suspicious patterns
+     */
+    private hasSuspiciousPatterns;
+}
+//# sourceMappingURL=wasm-validator.d.ts.map

package/dist/browser/hcs-12/validation/wasm-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-validator.d.ts","sourceRoot":"","sources":["../../../../src/hcs-12/validation/wasm-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAG5C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAsB;IAE3C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;IAE5D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAK7B;IAEH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAO;IAE1C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IAEpD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAmB;gBAEvC,MAAM,EAAE,MAAM;IAI1B;;OAEG;IACG,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAuFnE;;OAEG;IACG,oBAAoB,CACxB,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GACvC,OAAO,CAAC,oBAAoB,CAAC;IAiChC;;OAEG;IACG,qBAAqB,CAAC,UAAU,EAAE,GAAG,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAqB3E;;OAEG;IACG,eAAe,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IAQzD;;OAEG;IACG,aAAa,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAW1D;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAKtB;;OAEG;YACW,WAAW;IAmEzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAM9B"}

package/dist/browser/hcs-12/wasm/index.d.ts

@@ -0,0 +1,2 @@
+export * from './wasm-executor';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/hcs-12/wasm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hcs-12/wasm/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/browser/hcs-12/wasm/wasm-executor.d.ts

@@ -0,0 +1,44 @@
+import { Logger } from '../../utils/logger';
+import { ActionRegistration } from '../types';
+import { NetworkType } from '../../utils/types';
+export interface WasmExecutionContext {
+    method: string;
+    params: Record<string, any>;
+    state?: Record<string, any>;
+}
+export interface WasmExecutionResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    gasUsed?: number;
+}
+/**
+ * Executes WASM modules for HCS-12 actions
+ */
+export declare class WasmExecutor {
+    private logger;
+    private hrlResolver;
+    private network;
+    private wasmCache;
+    constructor(logger: Logger, network: NetworkType);
+    /**
+     * Execute a WASM action
+     */
+    execute(action: ActionRegistration, context: WasmExecutionContext): Promise<WasmExecutionResult>;
+    /**
+     * Load a WASM instance
+     */
+    /**
+     * Read a string from WASM memory
+     */
+    private readWasmString;
+    /**
+     * Execute JavaScript wrapper
+     */
+    private executeJavaScript;
+    /**
+     * Clear the WASM cache
+     */
+    clearCache(): void;
+}
+//# sourceMappingURL=wasm-executor.d.ts.map

package/dist/browser/hcs-12/wasm/wasm-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-executor.d.ts","sourceRoot":"","sources":["../../../../src/hcs-12/wasm/wasm-executor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAWD;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,SAAS,CAAgD;gBAErD,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW;IAMhD;;OAEG;IACG,OAAO,CACX,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC;IAqC/B;;OAEG;IAEH;;OAEG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;YACW,iBAAiB;IA8O/B;;OAEG;IACH,UAAU,IAAI,IAAI;CAGnB"}

package/dist/browser/hcs-14/adapters/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Common adapter metadata for issuers and resolvers.
+ */
+export interface AdapterMeta {
+    /** A stable identifier for the adapter (e.g., 'hedera/hiero'). */
+    id: string;
+    /** DID methods supported by this adapter (e.g., ['hedera']). */
+    didMethods: string[];
+    /** Supported CAIP-2 network identifiers, if applicable (e.g., ['hedera:testnet']). */
+    caip2Networks?: string[];
+    /** Supported CAIP-10 namespaces, if applicable (e.g., ['hedera', 'eip155']). */
+    caip10Namespaces?: string[];
+    /** Human-readable name for UI listings. */
+    displayName?: string;
+    /** Optional short description. */
+    description?: string;
+    /** Optional homepage or documentation URL. */
+    homepage?: string;
+    /** Optional author or organization name. */
+    author?: string;
+    /** Optional semantic version for the adapter implementation. */
+    version?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/browser/hcs-14/adapters/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/hcs-14/adapters/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,WAAW;IAC1B,kEAAkE;IAClE,EAAE,EAAE,MAAM,CAAC;IACX,gEAAgE;IAChE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,sFAAsF;IACtF,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,2CAA2C;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/browser/hcs-14/base58.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Minimal Base58 encoder/decoder (Bitcoin alphabet) with no external dependencies.
+ */
+export declare function base58Encode(bytes: Uint8Array): string;
+export declare function base58Decode(text: string): Uint8Array;
+export declare function multibaseB58btcDecode(zText: string): Uint8Array;
+//# sourceMappingURL=base58.d.ts.map

package/dist/browser/hcs-14/base58.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58.d.ts","sourceRoot":"","sources":["../../../src/hcs-14/base58.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CA0BtD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CA2BrD;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAG/D"}

package/dist/browser/hcs-14/browser.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './canonical';
+export * from './did';
+export * from './caip';
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser/hcs-14/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/hcs-14/browser.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC"}

package/dist/browser/hcs-14/caip.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CAIP helpers for Hedera alignment in HCS-14.
+ */
+export type HederaNetwork = 'mainnet' | 'testnet' | 'previewnet' | 'devnet';
+export declare function isHederaNetwork(value: string): value is HederaNetwork;
+export declare function isHederaCaip10(value: string): boolean;
+export declare function toHederaCaip10(network: HederaNetwork, accountId: string): string;
+export declare function parseHederaCaip10(value: string): {
+    network: HederaNetwork;
+    accountId: string;
+};
+export declare function isEip155Caip10(value: string): boolean;
+export declare function toEip155Caip10(chainId: number | string, address: string): string;
+//# sourceMappingURL=caip.d.ts.map

package/dist/browser/hcs-14/caip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caip.d.ts","sourceRoot":"","sources":["../../../src/hcs-14/caip.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,QAAQ,CAAC;AAS5E,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAErE;AAKD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,GAChB,MAAM,CAYR;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG;IAChD,OAAO,EAAE,aAAa,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB,CAIA;AAID,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,CAMR"}

package/dist/browser/hcs-14/canonical.d.ts

@@ -0,0 +1,3 @@
+import { CanonicalizationResult } from './types';
+export declare function canonicalizeAgentData(input: unknown): CanonicalizationResult;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/browser/hcs-14/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../../../src/hcs-14/canonical.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAGL,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAWjB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,CA4C5E"}

package/dist/browser/hcs-14/did.d.ts

@@ -0,0 +1,7 @@
+import { CanonicalAgentData, DidRoutingParams, ParsedHcs14Did } from './types';
+export declare function createUaid(existingDid: string, params?: DidRoutingParams): string;
+export declare function createUaid(input: CanonicalAgentData, params?: DidRoutingParams, options?: {
+    includeParams?: boolean;
+}): Promise<string>;
+export declare function parseHcs14Did(did: string): ParsedHcs14Did;
+//# sourceMappingURL=did.d.ts.map

package/dist/browser/hcs-14/did.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"did.d.ts","sourceRoot":"","sources":["../../../src/hcs-14/did.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAyG/E,wBAAgB,UAAU,CACxB,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,gBAAgB,GACxB,MAAM,CAAC;AACV,wBAAgB,UAAU,CACxB,KAAK,EAAE,kBAAkB,EACzB,MAAM,CAAC,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GACpC,OAAO,CAAC,MAAM,CAAC,CAAC;AAYnB,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAqCzD"}

package/dist/browser/hcs-14/index.d.ts

@@ -0,0 +1,18 @@
+export * from './types';
+export * from './canonical';
+export * from './did';
+export * from './caip';
+export * from './resolvers/types';
+export * from './resolvers/registry';
+export * from './resolvers/hiero';
+export * from './resolvers/hcs-11-profile';
+export * from './resolvers/aid-dns-web-profile';
+export * from './resolvers/ans-dns-web-profile';
+export * from './resolvers/uaid-dns-web-profile';
+export * from './resolvers/uaid-did-resolution-profile';
+export * from './resolvers/dns';
+export * from './sdk';
+export * from './issuers/types';
+export * from './issuers/registry';
+export * from './issuers/hiero';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/hcs-14/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hcs-14/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,yCAAyC,CAAC;AACxD,cAAc,iBAAiB,CAAC;AAChC,cAAc,OAAO,CAAC;AACtB,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC"}

package/dist/browser/hcs-14/issuers/hiero.d.ts

@@ -0,0 +1,8 @@
+import { DidIssueRequest, DidIssuer } from './types';
+import { AdapterMeta } from '../adapters/types';
+export declare class HederaHieroIssuer implements DidIssuer {
+    readonly meta: AdapterMeta;
+    supports(method: string): boolean;
+    issue(request: DidIssueRequest): Promise<string>;
+}
+//# sourceMappingURL=hiero.d.ts.map

package/dist/browser/hcs-14/issuers/hiero.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hiero.d.ts","sourceRoot":"","sources":["../../../../src/hcs-14/issuers/hiero.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAyB,SAAS,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAsGrD,qBAAa,iBAAkB,YAAW,SAAS;IACjD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAaxB;IAEF,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI3B,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;CAoBvD"}

package/dist/browser/hcs-14/issuers/registry.d.ts

@@ -0,0 +1,15 @@
+import { DidIssueRequest, DidIssuer, IssuerRegistryApi } from './types';
+export declare class IssuerRegistry implements IssuerRegistryApi {
+    private issuers;
+    register(issuer: DidIssuer): void;
+    list(): DidIssuer[];
+    /** Return issuers that support a given DID method. */
+    filterByDidMethod(method: string): DidIssuer[];
+    /** Return issuers that advertise a specific CAIP-2 network. */
+    filterByCaip2(network: string): DidIssuer[];
+    /** Generic predicate-based filter. */
+    filter(predicate: (issuer: DidIssuer) => boolean): DidIssuer[];
+    issue(request: DidIssueRequest): Promise<string>;
+}
+export declare const defaultIssuerRegistry: IssuerRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/browser/hcs-14/issuers/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/hcs-14/issuers/registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAExE,qBAAa,cAAe,YAAW,iBAAiB;IACtD,OAAO,CAAC,OAAO,CAAmB;IAElC,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAIjC,IAAI,IAAI,SAAS,EAAE;IAInB,sDAAsD;IACtD,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE;IAI9C,+DAA+D;IAC/D,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE;IAI3C,sCAAsC;IACtC,MAAM,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,GAAG,SAAS,EAAE;IAIxD,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;CAQvD;AAED,eAAO,MAAM,qBAAqB,gBAAuB,CAAC"}