@hashgraphonline/standards-sdk 0.0.6 → 0.0.8

package/dist/es/index.d.ts

@@ -1,7 +1,5 @@
 export * from './hcs-7';
-import * as HCS10 from './hcs-10';
-export { HCS10 };
-import * as HCS3 from './hcs-3/src';
-export { HCS3 };
+export * as HCS10 from './hcs-10';
+export * as HCS3 from './hcs-3/src';
 export * from './utils';
 export * from './inscribe';

package/dist/es/{inscription-sdk.es.js → standards-sdk.es.js}

@@ -9,4 +9,4 @@ export {
   q as inscribeWithSigner,
   s as retrieveInscription
 };
-//# sourceMappingURL=inscription-sdk.es.js.map
+//# sourceMappingURL=standards-sdk.es.js.map

package/dist/es/standards-sdk.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standards-sdk.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/umd/hcs-10/browser.d.ts

@@ -0,0 +1,109 @@
+import { PublicKey, TransactionReceipt } from '@hashgraph/sdk';
+import { HashinalsWalletConnectSDK } from '@hashgraphonline/hashinal-wc';
+import { Logger } from '../utils/logger';
+import { RetrievedInscriptionResult } from '@kiloscribe/inscription-sdk';
+import { Outbound, HCSMessage, LogLevel } from './outbound';
+import { AgentConfig, NetworkType } from './sdk';
+export type BrowserHCSClientConfig = {
+    network: 'mainnet' | 'testnet';
+    hwc: HashinalsWalletConnectSDK;
+    logLevel?: LogLevel;
+    guardedRegistryTopicId: string;
+    guardedRegistryBaseUrl: string;
+};
+interface AgentMetadata {
+    name: string;
+    description: string;
+    tags: string[];
+    version?: string;
+    type?: string;
+    logo?: string;
+    socials?: SocialLinks;
+}
+interface SocialLinks {
+    twitter?: string;
+    discord?: string;
+    github?: string;
+    website?: string;
+}
+export type BrowserAgentConfig = Omit<AgentConfig, 'client' | 'privateKey'> & {
+    client: BrowserHCSClient;
+};
+export declare class BrowserHCSClient extends Outbound {
+    private hwc;
+    protected logger: Logger;
+    private guardedRegistryTopicId;
+    private guardedRegistryBaseUrl;
+    private validTags;
+    constructor(config: BrowserHCSClientConfig);
+    sendMessage(connectionTopicId: string, operatorId: string, data: string, memo?: string): Promise<void>;
+    submitConnectionRequest(inboundTopicId: string, requestingAccountId: string, operatorId: string, memo: string): Promise<TransactionReceipt | undefined>;
+    recordOutboundConnectionConfirmation({ outboundTopicId, connectionRequestId, confirmedRequestId, connectionTopicId, operatorId, memo, }: {
+        outboundTopicId: string;
+        connectionRequestId: number;
+        confirmedRequestId: number;
+        connectionTopicId: string;
+        operatorId: string;
+        memo: string;
+    }): Promise<{
+        result?: TransactionReceipt;
+        error?: string;
+    }>;
+    getPublicKey(accountId: string): Promise<PublicKey>;
+    handleConnectionRequest(inboundTopicId: string, requestingAccountId: string, connectionId: number, connectionMemo?: string): Promise<{
+        connectionTopicId: string;
+        confirmedConnectionSequenceNumber: number;
+        operatorId: string;
+    }>;
+    confirmConnection(inboundTopicId: string, connectionTopicId: string, connectedAccountId: string, connectionId: number, operatorId: string, memo: string): Promise<number>;
+    submitMessage(topicId: string, content: string, metadata?: object, memo?: string): Promise<{
+        result?: TransactionReceipt;
+        error?: string;
+    }>;
+    createAgent(pfpBuffer: Buffer, pfpFileName: string, agentName: string, agentDescription: string, tags: string[], metadata: AgentMetadata): Promise<{
+        outboundTopicId: string;
+        inboundTopicId: string;
+        pfpTopicId: string;
+        profileTopicId: string;
+        error?: string;
+        success: boolean;
+    }>;
+    createAndRegisterAgent(name: string, description: string, tags: string[], metadata: AgentMetadata, pfpBuffer: Buffer, pfpFileName: string, network: NetworkType): Promise<BrowserAgentConfig>;
+    registerAgentWithGaurdedRegistry(accountId: string, inboundTopicId: string, metadata: {
+        tags: string[];
+        [key: string]: any;
+    }, network: string, maxAttempts?: number, delayMs?: number): Promise<{
+        error?: string;
+        success: boolean;
+    }>;
+    storeHCS11Profile(agentName: string, agentDescription: string, inboundTopicId: string, outboundTopicId: string, tags?: string[], metadata?: Record<string, any>, pfpBuffer?: Buffer, pfpFileName?: string): Promise<{
+        profileTopicId: string;
+        pfpTopicId?: string;
+        error?: string;
+        success: boolean;
+    }>;
+    createTopic(memo: string, adminKey?: boolean, submitKey?: boolean): Promise<{
+        success: boolean;
+        topicId?: string;
+        error?: string;
+    }>;
+    private submitPayload;
+    inscribeFile(buffer: Buffer, fileName: string): Promise<RetrievedInscriptionResult>;
+    getAccountAndSigner(): {
+        accountId: string;
+        signer: any;
+    };
+    protected getMessages(topicId: string): Promise<{
+        messages: HCSMessage[];
+    }>;
+    retrieveOutboundConnectTopicFromNetwork(accountId: string): Promise<{
+        inboundTopic: string;
+        outboundTopic: string;
+    }>;
+    inscribePfp(buffer: Buffer, fileName: string): Promise<{
+        pfpTopicId: string;
+        success: boolean;
+        error?: string;
+    }>;
+}
+export {};

package/dist/umd/hcs-10/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class PayloadSizeError extends Error {
+    payloadSize: number;
+    constructor(message: string, payloadSize: number);
+}
+export declare class AccountCreationError extends Error {
+    constructor(message: string);
+}
+export declare class TopicCreationError extends Error {
+    constructor(message: string);
+}
+export declare class ConnectionConfirmationError extends Error {
+    constructor(message: string);
+}

package/dist/umd/hcs-10/index.d.ts

@@ -0,0 +1,4 @@
+export * from './sdk';
+export * from './browser';
+export * from './errors';
+export * from './outbound';

package/dist/umd/hcs-10/outbound.d.ts

@@ -0,0 +1,140 @@
+import { Logger } from '../utils/logger';
+import { Registration } from './registrations';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface AccountResponse {
+    account: string;
+    alias: string;
+    auto_renew_period: number;
+    balance: Balance;
+    created_timestamp: string;
+    decline_reward: boolean;
+    deleted: boolean;
+    ethereum_nonce: number;
+    evm_address: string;
+    expiry_timestamp: string;
+    key: Key;
+    max_automatic_token_associations: number;
+    memo: string;
+    pending_reward: number;
+    receiver_sig_required: boolean;
+    staked_account_id: string | null;
+    staked_node_id: string | null;
+    stake_period_start: string | null;
+    transactions: Transaction[];
+    links: Links;
+}
+export interface Balance {
+    balance: number;
+    timestamp: string;
+    tokens: TokenBalance[];
+}
+export interface TokenBalance {
+    token_id: string;
+    balance: number;
+}
+export interface Key {
+    _type: string;
+    key: string;
+}
+export interface Transaction {
+    bytes: string | null;
+    charged_tx_fee: number;
+    consensus_timestamp: string;
+    entity_id: string | null;
+    max_fee: string;
+    memo_base64: string;
+    name: string;
+    nft_transfers: NftTransfer[];
+    node: string;
+    nonce: number;
+    parent_consensus_timestamp: string | null;
+    result: string;
+    scheduled: boolean;
+    staking_reward_transfers: Transfer[];
+    token_transfers: TokenTransfer[];
+    transaction_hash: string;
+    transaction_id: string;
+    transfers: Transfer[];
+    valid_duration_seconds: string;
+    valid_start_timestamp: string;
+}
+export interface Transfer {
+    account: string;
+    amount: number;
+    is_approval: boolean;
+}
+export interface TokenTransfer {
+    token_id: string;
+    account: string;
+    amount: string;
+    is_approval: boolean;
+}
+export interface NftTransfer {
+    receiver_account_id: string;
+    sender_account_id: string;
+    serial_number: number;
+    is_approval: boolean;
+}
+export interface Links {
+    next: string;
+}
+export interface OutboundConfig {
+    network: 'mainnet' | 'testnet';
+    logLevel?: LogLevel;
+}
+export interface TopicInfo {
+    inboundTopic: string;
+    outboundTopic: string;
+}
+export interface HCSMessage {
+    p: 'hcs-10';
+    op: 'connection_request' | 'connection_created' | 'message';
+    data: string;
+    created?: Date;
+    consensus_timestamp?: string;
+    m?: string;
+    payer: string;
+    outbound_topic_id?: string;
+    connection_request_id?: number;
+    confirmed_request_id?: number;
+    connection_topic_id?: string;
+    connected_account_id?: string;
+    requesting_account_id?: string;
+    connection_id?: number;
+    sequence_number: number;
+    operator_id?: string;
+}
+export declare abstract class Outbound extends Registration {
+    private static topicCache;
+    protected network: string;
+    protected logger: Logger;
+    constructor(config: OutboundConfig);
+    abstract getAccountAndSigner(): {
+        accountId: string;
+        signer: any;
+    };
+    protected abstract getMessages(topicId: string): Promise<{
+        messages: HCSMessage[];
+    }>;
+    requestAccount(account: string): Promise<AccountResponse>;
+    getAccountMemo(accountId: string): Promise<string | null>;
+    private getTopicInfoFromMemo;
+    private getMirrorNodeUrl;
+    getTopicInfo(accountId: string): Promise<TopicInfo | null>;
+    retrieveOutboundConnectTopic(accountId: string): Promise<string | null>;
+    retrieveOutboundConnectTopicFromNetwork(accountId: string): Promise<TopicInfo>;
+    retrieveOutboundMessages(agentAccountId: string): Promise<HCSMessage[]>;
+    hasConnectionCreated(agentAccountId: string, connectionId: number): Promise<boolean>;
+    clearCache(): void;
+}
+export declare class OutboundCache {
+    private static instance;
+    private cache;
+    private cacheExpiry;
+    private readonly CACHE_TTL;
+    private constructor();
+    static getInstance(): OutboundCache;
+    set(key: string, value: TopicInfo): void;
+    get(key: string): TopicInfo | undefined;
+    clear(): void;
+}

package/dist/umd/hcs-10/registrations.d.ts

@@ -0,0 +1,26 @@
+import { AgentMetadata } from './sdk';
+export interface RegistrationSearchOptions {
+    tags?: string[];
+    accountId?: string;
+    network?: string;
+}
+export interface RegistrationSearchResult {
+    registrations: Array<{
+        id: string;
+        transaction_id: string;
+        status: 'pending' | 'success' | 'failed';
+        network: string;
+        account_id: string;
+        requester_topic_id: string;
+        operator_id: string;
+        metadata: AgentMetadata;
+        registry_topic_id: string;
+        created_at: string;
+        updated_at: string;
+    }>;
+    error?: string;
+    success: boolean;
+}
+export declare abstract class Registration {
+    findRegistrations(options?: RegistrationSearchOptions): Promise<RegistrationSearchResult>;
+}

package/dist/umd/hcs-10/sdk.d.ts

@@ -0,0 +1,173 @@
+import { Client, PrivateKey, Transaction, TransactionReceipt, PublicKey } from '@hashgraph/sdk';
+import { HCSClientConfig } from 'hcs10-sdk';
+import { RetrievedInscriptionResult } from '@kiloscribe/inscription-sdk';
+import { Logger } from '../utils/logger';
+import { Outbound, HCSMessage } from './outbound';
+export declare class HCS10Client extends Outbound {
+    private client;
+    private operatorPrivateKey;
+    protected network: string;
+    protected logger: Logger;
+    protected guardedRegistryBaseUrl: string;
+    constructor(config: HCSClientConfig);
+    getClient(): Client;
+    createAccount(): Promise<{
+        accountId: string;
+        privateKey: string;
+    }>;
+    createAgent(pfpBuffer: Buffer, pfpFileName: string, agentName: string, agentDescription: string, tags: string[], metadata: AgentMetadata): Promise<{
+        outboundTopicId: string;
+        inboundTopicId: string;
+        pfpTopicId: string;
+        profileTopicId: string;
+    }>;
+    inscribePfp(buffer: Buffer, fileName: string): Promise<{
+        pfpTopicId: string;
+        transactionId: string;
+        success: boolean;
+    }>;
+    storeHCS11Profile(agentName: string, agentDescription: string, inboundTopicId: string, outboundTopicId: string, tags?: string[], metadata?: Record<string, any>, pfpBuffer?: Buffer, pfpFileName?: string): Promise<{
+        profileTopicId: string;
+        pfpTopicId?: string;
+        transactionId: string;
+        success: boolean;
+    }>;
+    retrieveOutboundConnectTopicFromNetwork(accountId: string): Promise<{
+        inboundTopic: string;
+        outboundTopic: string;
+    }>;
+    registerAgentWithGaurdedRegistry(accountId: string, inboundTopicId: string, metadata: {
+        tags: string[];
+        [key: string]: any;
+    }, network: string, maxAttempts?: number, delayMs?: number): Promise<AgentRegistrationResult>;
+    private executeRegistration;
+    private checkRegistrationStatus;
+    private waitForConfirmation;
+    /**
+     * Registers an agent with the guarded registry. Should be called by a registry.
+     * @param registryTopicId - The topic ID of the guarded registry.
+     * @param accountId - The account ID of the agent
+     * @param inboundTopicId - The topic ID of the inbound topic
+     * @param metadata - The metadata of the agent
+     * @param memo - The memo of the agent
+     * @param submitKey - The submit key of the agent
+     */
+    registerAgent(registryTopicId: string, accountId: string, inboundTopicId: string, metadata: {
+        tags: string[];
+        [key: string]: any;
+    }, memo: string, submitKey?: PrivateKey): Promise<void>;
+    handleConnectionRequest(inboundTopicId: string, requestingAccountId: string, connectionRequestId: number): Promise<{
+        connectionTopicId: string;
+        confirmedConnectionSequenceNumber: number;
+        operatorId: string;
+    }>;
+    confirmConnection(inboundTopicId: string, connectionTopicId: string, connectedAccountId: string, connectionId: number, operatorId: string, memo: string, submitKey?: PrivateKey): Promise<number>;
+    sendMessage(connectionTopicId: string, operatorId: string, data: string, memo?: string, submitKey?: PrivateKey): Promise<void>;
+    getPublicKey(accountId: string): Promise<PublicKey>;
+    createThresholdTopic(memo: string, requesterPublicKey: string): Promise<string>;
+    createTopic(memo: string, adminKey?: boolean, submitKey?: boolean): Promise<string>;
+    submitMessage(topicId: string, message: string, submitKey?: PrivateKey): Promise<TransactionReceipt>;
+    private submitPayload;
+    queryTopicMessages(topicId: string): Promise<string[]>;
+    submitConnectionRequest(inboundTopicId: string, requestingAccountId: string, operatorId: string, memo: string): Promise<TransactionReceipt>;
+    recordOutboundConnectionConfirmation({ outboundTopicId, connectionRequestId, confirmedRequestId, connectionTopicId, operatorId, memo, }: {
+        outboundTopicId: string;
+        connectionRequestId: number;
+        confirmedRequestId: number;
+        connectionTopicId: string;
+        operatorId: string;
+        memo: string;
+    }): Promise<TransactionReceipt>;
+    inscribeFile(buffer: Buffer, fileName: string): Promise<RetrievedInscriptionResult>;
+    waitForConnectionConfirmation(inboundTopicId: string, connectionRequestId: number, maxAttempts?: number, delayMs?: number): Promise<{
+        connectionTopicId: string;
+        confirmedBy: string;
+        sequence_number: number;
+        memo: string;
+    }>;
+    getAccountAndSigner(): {
+        accountId: string;
+        signer: any;
+    };
+    protected getMessages(topicId: string): Promise<{
+        messages: HCSMessage[];
+    }>;
+    /**
+     * Creates and registers an agent with a Gaurded registry.
+     *
+     * This function performs the following steps:
+     * 1. Creates a new account if no existing account is provided.
+     * 2. Initializes an HCS10 client with the new account.
+     * 3. Creates an agent on the client.
+     * 4. Registers the agent with the Hashgraph Online Gaurded Registry.
+     *
+     * @param name
+     * @param description
+     * @param tags
+     * @param metadata
+     * @param pfpBuffer
+     * @param pfpFileName
+     * @param network
+     * @param existingAccount
+     * @returns
+     */
+    createAndRegisterAgent(name: string, description: string, tags: string[], metadata: AgentMetadata, pfpBuffer: Buffer, pfpFileName: string, network: NetworkType, existingAccount?: {
+        accountId: string;
+        privateKey: string;
+    }): Promise<AgentConfig>;
+}
+export interface ValidationError {
+    validation: string;
+    code: string;
+    message: string;
+    path: string[];
+}
+export interface AgentRegistrationResult {
+    transaction?: Transaction;
+    transactionId?: string;
+    confirmed?: boolean;
+    validationErrors?: ValidationError[];
+    error?: string;
+    success: boolean;
+}
+export interface AgentCreationResult {
+    outboundTopicId: string;
+    inboundTopicId: string;
+    registration?: AgentRegistrationResult;
+    error?: string;
+    success: boolean;
+}
+export interface AgentMetadata {
+    name: string;
+    description: string;
+    tags: string[];
+    type?: 'assistant' | 'agent' | 'bot';
+    version?: string;
+    logo?: string;
+    socials?: {
+        x?: string;
+        github?: string;
+        website?: string;
+        discord?: string;
+    };
+    [key: string]: any;
+}
+export type RegistrationOptions = {
+    maxAttempts: number;
+    delayMs: number;
+    baseUrl: string;
+};
+export type RegistrationStatus = {
+    status: 'pending' | 'success' | 'failed';
+};
+export type NetworkType = 'mainnet' | 'testnet';
+export type AgentConfig = {
+    accountId: string;
+    privateKey: string;
+    operatorId: string;
+    inboundTopicId: string;
+    outboundTopicId: string;
+    profileTopicId: string;
+    pfpTopicId?: string;
+    client: HCS10Client;
+};

package/dist/umd/hcs-3/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/dist/umd/hcs-3/src/index.d.ts

@@ -0,0 +1,48 @@
+import { HCSSDK, LoadQueueItem, HCSConfigMapping, HCSConfig, LoadType } from './types';
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare class HCS implements HCSSDK {
+    config: HCSConfig;
+    configMapping: HCSConfigMapping;
+    LoadedScripts: Record<string, string>;
+    LoadedWasm: Record<string, WebAssembly.Instance>;
+    LoadedImages: Record<string, string>;
+    LoadedVideos: Record<string, string>;
+    LoadedAudios: Record<string, HTMLAudioElement>;
+    LoadedAudioUrls: Record<string, string>;
+    LoadedGLBs: Record<string, string>;
+    scriptLoadedEvent: Event;
+    loadQueue: LoadQueueItem[];
+    isProcessingQueue: boolean;
+    private modelViewerLoaded;
+    private modelViewerLoading;
+    private logger;
+    constructor();
+    private createFallbackLogger;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    loadConfigFromHTML(): void;
+    updateLoadingStatus(id: string, status: string): void;
+    fetchWithRetry(url: string, retries?: number, backoff?: number): Promise<Response>;
+    sleep(ms: number): Promise<unknown>;
+    isDuplicate(topicId: string): boolean;
+    retrieveHCS1Data(topicId: string, cdnUrl?: string, network?: string): Promise<Blob>;
+    loadScript(scriptElement: HTMLElement): Promise<void>;
+    loadModuleExports(scriptId: string): Promise<any>;
+    loadStylesheet(linkElement: HTMLElement): Promise<void>;
+    loadImage(imageElement: HTMLElement): Promise<void>;
+    loadMedia(mediaElement: HTMLElement, mediaType: 'video' | 'audio'): Promise<void>;
+    private loadModelViewer;
+    loadGLB(glbElement: HTMLElement): Promise<void>;
+    loadResource(element: HTMLElement, type: LoadType, order: number): Promise<void>;
+    processQueue(): Promise<void>;
+    private replaceHCSInStyle;
+    private processInlineStyles;
+    init(): Promise<void>;
+    preloadImage(topicId: string): Promise<string>;
+    preloadAudio(topicId: string): Promise<string>;
+    playAudio(topicId: string, volume?: number): Promise<void>;
+    pauseAudio(topicId: string): Promise<void>;
+    loadAndPlayAudio(topicId: string, autoplay?: boolean, volume?: number): Promise<void>;
+}
+declare const _default: any;
+export default _default;

package/dist/umd/hcs-7/evm-bridge.d.ts

@@ -0,0 +1,24 @@
+import { AccountId, ContractId } from '@hashgraph/sdk';
+import { EVMConfig } from './wasm-bridge';
+export interface EVMCache {
+    get(key: string): Promise<string | undefined> | string | undefined;
+    set(key: string, value: string): Promise<void> | void;
+    delete(key: string): Promise<void> | void;
+    clear(): Promise<void> | void;
+}
+export declare class EVMBridge {
+    network: string;
+    mirrorNodeUrl: string;
+    private cache;
+    private logger;
+    constructor(network?: string, mirrorNodeUrl?: string, cache?: EVMCache);
+    executeCommands(evmConfigs: EVMConfig[], initialState?: Record<string, string>): Promise<{
+        results: Record<string, any>;
+        stateData: Record<string, any>;
+    }>;
+    executeCommand(evmConfig: EVMConfig, stateData?: Record<string, string>): Promise<any>;
+    readFromMirrorNode(command: string, from: AccountId, to: ContractId): Promise<any>;
+    clearCache(): Promise<void>;
+    clearCacheForContract(contractAddress: string, functionName: string): Promise<void>;
+    setLogLevel(level: 'debug' | 'info' | 'warn' | 'error'): void;
+}

package/dist/umd/hcs-7/index.d.ts

@@ -0,0 +1,2 @@
+export * from './wasm-bridge';
+export * from './evm-bridge';

package/dist/umd/hcs-7/redis-cache.d.ts

@@ -0,0 +1,25 @@
+import { EVMCache } from './evm-bridge';
+export interface RedisConfig {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    tls?: boolean;
+    connectTimeout?: number;
+    retryStrategy?: (times: number) => number | void;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+}
+export declare class RedisCache implements EVMCache {
+    private client;
+    private prefix;
+    private logger;
+    constructor(config?: RedisConfig);
+    private getKey;
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    disconnect(): Promise<void>;
+    setLogLevel(level: 'debug' | 'info' | 'warn' | 'error'): void;
+}

package/dist/umd/hcs-7/wasm-bridge.d.ts

@@ -0,0 +1,71 @@
+export interface BaseMessage {
+    p: string;
+    op: string;
+    m: string;
+    t?: string;
+    t_id?: string;
+    d?: Record<string, unknown>;
+}
+export interface EVMConfig extends BaseMessage {
+    c: {
+        contractAddress: string;
+        abi: {
+            inputs: Array<{
+                name: string;
+                type: string;
+            }>;
+            name: string;
+            outputs: Array<{
+                name: string;
+                type: string;
+            }>;
+            stateMutability: string;
+            type: string;
+        };
+    };
+}
+export interface WASMConfig extends BaseMessage {
+    c: {
+        wasmTopicId: string;
+        inputType: {
+            stateData: Record<string, string>;
+        };
+        outputType: {
+            type: string;
+            format: string;
+        };
+    };
+}
+export interface WasmExports extends WebAssembly.Exports {
+    __wbindgen_add_to_stack_pointer: (a: number) => number;
+    __wbindgen_malloc: (a: number, b: number) => number;
+    __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    __wbindgen_free: (a: number, b: number, c: number) => void;
+    memory: WebAssembly.Memory;
+    process_state: (state_json: string, messages_json: string) => string;
+    get_params: () => string;
+    [key: string]: any;
+}
+export declare class WasmBridge {
+    wasm: WasmExports | null;
+    private WASM_VECTOR_LEN;
+    private cachedUint8Memory;
+    private cachedDataViewMemory;
+    private readonly textEncoder;
+    private readonly textDecoder;
+    private logger;
+    constructor();
+    setLogLevel(level: 'debug' | 'info' | 'warn' | 'error'): void;
+    get wasmInstance(): WasmExports;
+    private getUint8Memory;
+    private getDataViewMemory;
+    private encodeString;
+    private passStringToWasm;
+    private getStringFromWasm;
+    createWasmFunction(wasmFn: (...args: any[]) => any): (...args: string[]) => string;
+    initWasm(wasmBytes: BufferSource): Promise<WasmExports>;
+    createStateData(wasmConfig: WASMConfig, stateData?: Record<string, any>): Record<string, any>;
+    private getDefaultValueForType;
+    executeWasm(stateData: Record<string, any>, messages: BaseMessage[]): string;
+    getParams(): string;
+}

package/dist/umd/index.d.ts

@@ -0,0 +1,5 @@
+export * from './hcs-7';
+export * as HCS10 from './hcs-10';
+export * as HCS3 from './hcs-3/src';
+export * from './utils';
+export * from './inscribe';

package/dist/umd/inscribe/index.d.ts

@@ -0,0 +1,2 @@
+export * from './inscriber';
+export * from './types';