@parity/truapi 0.1.0

package/dist/generated/client.js

@@ -0,0 +1,1081 @@
+// Auto-generated by truapi-codegen. Do not edit.
+import { err, ok } from "neverthrow";
+import * as S from "../scale.js";
+import { SubscriptionError } from "../transport.js";
+import * as T from "./types.js";
+import * as W from "./wire-table.js";
+export { SubscriptionError };
+export const TRUAPI_VERSION = 1;
+export const TRUAPI_CODEC_VERSION = 1;
+function toSubscriptionError(error) {
+    if (error instanceof SubscriptionError)
+        return error;
+    const cause = error instanceof Error ? error : new Error(String(error));
+    return new SubscriptionError(cause.message, { cause });
+}
+function createObservable({ transport, ids, payload, decodeItem, decodeInterrupt, }) {
+    return {
+        subscribe(observer = {}) {
+            let closed = false;
+            let raw;
+            const fail = (error, stop = true) => {
+                if (closed)
+                    return;
+                closed = true;
+                try {
+                    if (stop)
+                        raw?.unsubscribe();
+                }
+                finally {
+                    observer.error?.(toSubscriptionError(error));
+                }
+            };
+            raw = transport.subscribeRaw({
+                ids,
+                payload,
+                onReceive: (payload) => {
+                    if (closed)
+                        return;
+                    try {
+                        observer.next?.(decodeItem(payload));
+                    }
+                    catch (error) {
+                        fail(error);
+                    }
+                },
+                onInterrupt: (payload) => {
+                    if (closed)
+                        return;
+                    if (decodeInterrupt) {
+                        let reason;
+                        try {
+                            reason = decodeInterrupt(payload);
+                        }
+                        catch (error) {
+                            fail(error, false);
+                            return;
+                        }
+                        fail(new SubscriptionError("Subscription interrupted", { reason }), false);
+                        return;
+                    }
+                    closed = true;
+                    observer.complete?.();
+                },
+                onClose: fail,
+            });
+            return {
+                get subscriptionId() {
+                    return raw?.subscriptionId ?? "";
+                },
+                unsubscribe: () => {
+                    if (closed)
+                        return;
+                    closed = true;
+                    raw?.unsubscribe();
+                },
+            };
+        },
+    };
+}
+/** Account lookup, aliasing, and proof generation. */
+export class AccountClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Subscribe to account connection status changes. */
+    connectionStatusSubscribe() {
+        return createObservable({
+            transport: this.transport,
+            ids: W.ACCOUNT_CONNECTION_STATUS_SUBSCRIBE,
+            payload: S.indexedTaggedUnion({ V1: [0, S._void] }).enc({
+                tag: "V1",
+                value: undefined,
+            }),
+            decodeItem: (payload) => T.VersionedHostAccountConnectionStatusSubscribeItem.dec(payload).value,
+        });
+    }
+    /** Retrieve a product-scoped account. */
+    async getAccount(request) {
+        const result = await this.transport.request({
+            ids: W.ACCOUNT_GET_ACCOUNT,
+            payload: T.VersionedHostAccountGetRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostAccountGetResponse, T.HostAccountGetError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Retrieve a contextual alias for a product account. */
+    async getAccountAlias(request) {
+        const result = await this.transport.request({
+            ids: W.ACCOUNT_GET_ACCOUNT_ALIAS,
+            payload: T.VersionedHostAccountGetAliasRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostAccountGetAliasResponse, T.HostAccountGetError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Generate a ring VRF proof for a product account. */
+    async createAccountProof(request) {
+        const result = await this.transport.request({
+            ids: W.ACCOUNT_CREATE_ACCOUNT_PROOF,
+            payload: T.VersionedHostAccountCreateProofRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostAccountCreateProofResponse, T.HostAccountCreateProofError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** List non-product accounts the user owns. */
+    async getLegacyAccounts() {
+        const result = await this.transport.request({
+            ids: W.ACCOUNT_GET_LEGACY_ACCOUNTS,
+            payload: T.VersionedHostGetLegacyAccountsRequest.enc({
+                tag: "V1",
+                value: undefined,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostGetLegacyAccountsResponse, T.HostAccountGetError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Fetch the user's primary identity. */
+    async getUserId() {
+        const result = await this.transport.request({
+            ids: W.ACCOUNT_GET_USER_ID,
+            payload: T.VersionedHostGetUserIdRequest.enc({
+                tag: "V1",
+                value: undefined,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostGetUserIdResponse, T.HostGetUserIdError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /**
+     * Request the host to present the login flow to the user.
+     *
+     * Products should call this in response to a user action (e.g. tapping a
+     * "Sign in" button), not automatically on load.
+     */
+    async requestLogin(request) {
+        const result = await this.transport.request({
+            ids: W.ACCOUNT_REQUEST_LOGIN,
+            payload: T.VersionedHostRequestLoginRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostRequestLoginResponse, T.HostRequestLoginError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Chain interaction methods. */
+export class ChainClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Follow the chain head and receive block events. */
+    followHeadSubscribe({ request, }) {
+        return createObservable({
+            transport: this.transport,
+            ids: W.CHAIN_FOLLOW_HEAD_SUBSCRIBE,
+            payload: T.VersionedRemoteChainHeadFollowRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeItem: (payload) => T.VersionedRemoteChainHeadFollowItem.dec(payload).value,
+        });
+    }
+    /** Fetch a block header. */
+    async getHeadHeader(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_GET_HEAD_HEADER,
+            payload: T.VersionedRemoteChainHeadHeaderRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainHeadHeaderResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Fetch a block body. */
+    async getHeadBody(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_GET_HEAD_BODY,
+            payload: T.VersionedRemoteChainHeadBodyRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainHeadBodyResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Query runtime storage at a specific block. */
+    async getHeadStorage(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_GET_HEAD_STORAGE,
+            payload: T.VersionedRemoteChainHeadStorageRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainHeadStorageResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Invoke a runtime call at a specific block. */
+    async callHead(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_CALL_HEAD,
+            payload: T.VersionedRemoteChainHeadCallRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainHeadCallResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Release pinned blocks. */
+    async unpinHead(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_UNPIN_HEAD,
+            payload: T.VersionedRemoteChainHeadUnpinRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.GenericError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Continue a paused chain-head operation. */
+    async continueHead(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_CONTINUE_HEAD,
+            payload: T.VersionedRemoteChainHeadContinueRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.GenericError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Stop a chain-head operation. */
+    async stopHeadOperation(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_STOP_HEAD_OPERATION,
+            payload: T.VersionedRemoteChainHeadStopOperationRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.GenericError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Fetch the canonical genesis hash for a chain. */
+    async getSpecGenesisHash(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_GET_SPEC_GENESIS_HASH,
+            payload: T.VersionedRemoteChainSpecGenesisHashRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainSpecGenesisHashResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Fetch the display name of a chain. */
+    async getSpecChainName(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_GET_SPEC_CHAIN_NAME,
+            payload: T.VersionedRemoteChainSpecChainNameRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainSpecChainNameResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Fetch the JSON-encoded properties of a chain. */
+    async getSpecProperties(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_GET_SPEC_PROPERTIES,
+            payload: T.VersionedRemoteChainSpecPropertiesRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainSpecPropertiesResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Broadcast a signed transaction. */
+    async broadcastTransaction(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_BROADCAST_TRANSACTION,
+            payload: T.VersionedRemoteChainTransactionBroadcastRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteChainTransactionBroadcastResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Stop a transaction broadcast. */
+    async stopTransaction(request) {
+        const result = await this.transport.request({
+            ids: W.CHAIN_STOP_TRANSACTION,
+            payload: T.VersionedRemoteChainTransactionStopRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.GenericError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Chat room, bot, and message APIs. */
+export class ChatClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Create a chat room. */
+    async createRoom(request) {
+        const result = await this.transport.request({
+            ids: W.CHAT_CREATE_ROOM,
+            payload: T.VersionedHostChatCreateRoomRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostChatCreateRoomResponse, T.HostChatCreateRoomError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Register a chat bot. */
+    async registerBot(request) {
+        const result = await this.transport.request({
+            ids: W.CHAT_REGISTER_BOT,
+            payload: T.VersionedHostChatRegisterBotRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostChatRegisterBotResponse, T.HostChatRegisterBotError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Subscribe to the list of chat rooms. */
+    listSubscribe() {
+        return createObservable({
+            transport: this.transport,
+            ids: W.CHAT_LIST_SUBSCRIBE,
+            payload: S.indexedTaggedUnion({ V1: [0, S._void] }).enc({
+                tag: "V1",
+                value: undefined,
+            }),
+            decodeItem: (payload) => T.VersionedHostChatListSubscribeItem.dec(payload).value,
+        });
+    }
+    /** Post a message to a chat room. */
+    async postMessage(request) {
+        const result = await this.transport.request({
+            ids: W.CHAT_POST_MESSAGE,
+            payload: T.VersionedHostChatPostMessageRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostChatPostMessageResponse, T.HostChatPostMessageError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Subscribe to received chat actions. */
+    actionSubscribe() {
+        return createObservable({
+            transport: this.transport,
+            ids: W.CHAT_ACTION_SUBSCRIBE,
+            payload: S.indexedTaggedUnion({ V1: [0, S._void] }).enc({
+                tag: "V1",
+                value: undefined,
+            }),
+            decodeItem: (payload) => T.VersionedHostChatActionSubscribeItem.dec(payload).value,
+        });
+    }
+    /**
+     * Subscribe to custom message render requests from the host. Each
+     * emitted item is a [`CustomRendererNode`](crate::v01::CustomRendererNode)
+     * tree describing the rendered UI.
+     */
+    customMessageRenderSubscribe({ request, }) {
+        return createObservable({
+            transport: this.transport,
+            ids: W.CHAT_CUSTOM_MESSAGE_RENDER_SUBSCRIBE,
+            payload: T.VersionedProductChatCustomMessageRenderSubscribeRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeItem: (payload) => T.VersionedProductChatCustomMessageRenderSubscribeItem.dec(payload).value,
+        });
+    }
+}
+/** Deterministic entropy derivation. */
+export class EntropyClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Derive deterministic entropy. */
+    async derive(request) {
+        const result = await this.transport.request({
+            ids: W.ENTROPY_DERIVE,
+            payload: T.VersionedHostDeriveEntropyRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostDeriveEntropyResponse, T.HostDeriveEntropyError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** JSON-RPC transport methods. */
+export class JsonRpcClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Send a JSON-RPC message. */
+    async sendMessage(request) {
+        const result = await this.transport.request({
+            ids: W.JSON_RPC_SEND_MESSAGE,
+            payload: T.VersionedHostJsonrpcMessageSendRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.GenericError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Subscribe to inbound JSON-RPC messages. */
+    subscribeMessages({ request, }) {
+        return createObservable({
+            transport: this.transport,
+            ids: W.JSON_RPC_SUBSCRIBE_MESSAGES,
+            payload: T.VersionedHostJsonrpcMessageSubscribeRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeItem: (payload) => T.VersionedHostJsonrpcMessageSubscribeItem.dec(payload).value,
+        });
+    }
+}
+/** Local key/value storage scoped to the calling product. */
+export class LocalStorageClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Read a value by key. */
+    async read(request) {
+        const result = await this.transport.request({
+            ids: W.LOCAL_STORAGE_READ,
+            payload: T.VersionedHostLocalStorageReadRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostLocalStorageReadResponse, T.HostLocalStorageReadError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Write a value to a key. */
+    async write(request) {
+        const result = await this.transport.request({
+            ids: W.LOCAL_STORAGE_WRITE,
+            payload: T.VersionedHostLocalStorageWriteRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.HostLocalStorageReadError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Clear a value by key. */
+    async clear(request) {
+        const result = await this.transport.request({
+            ids: W.LOCAL_STORAGE_CLEAR,
+            payload: T.VersionedHostLocalStorageClearRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.HostLocalStorageReadError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Payment request and balance/status subscription methods. */
+export class PaymentClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Subscribe to payment balance updates. */
+    balanceSubscribe() {
+        return createObservable({
+            transport: this.transport,
+            ids: W.PAYMENT_BALANCE_SUBSCRIBE,
+            payload: T.VersionedHostPaymentBalanceSubscribeRequest.enc({
+                tag: "V1",
+                value: undefined,
+            }),
+            decodeItem: (payload) => T.VersionedHostPaymentBalanceSubscribeItem.dec(payload).value,
+            decodeInterrupt: (payload) => T.VersionedHostPaymentBalanceSubscribeError.dec(payload).value,
+        });
+    }
+    /** Request a payment from the user. */
+    async request(request) {
+        const result = await this.transport.request({
+            ids: W.PAYMENT_REQUEST,
+            payload: T.VersionedHostPaymentRequestRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostPaymentRequestResponse, T.HostPaymentRequestError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Subscribe to payment lifecycle updates for a specific payment. */
+    statusSubscribe({ request, }) {
+        return createObservable({
+            transport: this.transport,
+            ids: W.PAYMENT_STATUS_SUBSCRIBE,
+            payload: T.VersionedHostPaymentStatusSubscribeRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeItem: (payload) => T.VersionedHostPaymentStatusSubscribeItem.dec(payload).value,
+            decodeInterrupt: (payload) => T.VersionedHostPaymentStatusSubscribeError.dec(payload).value,
+        });
+    }
+    /** Top up the user's payment balance. */
+    async topUp(request) {
+        const result = await this.transport.request({
+            ids: W.PAYMENT_TOP_UP,
+            payload: T.VersionedHostPaymentTopUpRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.HostPaymentTopUpError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Permission request methods. */
+export class PermissionsClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Request a device-capability permission from the user. */
+    async requestDevicePermission(request) {
+        const result = await this.transport.request({
+            ids: W.PERMISSIONS_REQUEST_DEVICE_PERMISSION,
+            payload: T.VersionedHostDevicePermissionRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostDevicePermissionResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Request one or more remote-operation permissions. */
+    async requestRemotePermission(request) {
+        const result = await this.transport.request({
+            ids: W.PERMISSIONS_REQUEST_REMOTE_PERMISSION,
+            payload: T.VersionedRemotePermissionRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemotePermissionResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Preimage lookup and submission methods. */
+export class PreimageClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Subscribe to preimage lookups for a given key. */
+    lookupSubscribe({ request, }) {
+        return createObservable({
+            transport: this.transport,
+            ids: W.PREIMAGE_LOOKUP_SUBSCRIBE,
+            payload: T.VersionedRemotePreimageLookupSubscribeRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeItem: (payload) => T.VersionedRemotePreimageLookupSubscribeItem.dec(payload).value,
+        });
+    }
+    /** Submit a preimage. Returns the preimage key (hash) on success. */
+    async submit(request) {
+        const result = await this.transport.request({
+            ids: W.PREIMAGE_SUBMIT,
+            payload: T.VersionedRemotePreimageSubmitRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S.Hex(), T.PreimageSubmitError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Resource pre-allocation (allowance management). */
+export class ResourceAllocationClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Request the host to pre-allocate one or more resources. */
+    async request(request) {
+        const result = await this.transport.request({
+            ids: W.RESOURCE_ALLOCATION_REQUEST,
+            payload: T.VersionedHostRequestResourceAllocationRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostRequestResourceAllocationResponse, T.ResourceAllocationError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Signing operations. */
+export class SigningClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Construct a signed transaction for a product account. */
+    async createTransaction(request) {
+        const result = await this.transport.request({
+            ids: W.SIGNING_CREATE_TRANSACTION,
+            payload: T.VersionedHostCreateTransactionRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostCreateTransactionResponse, T.HostCreateTransactionError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Construct a signed transaction for a non-product account. */
+    async createTransactionWithLegacyAccount(request) {
+        const result = await this.transport.request({
+            ids: W.SIGNING_CREATE_TRANSACTION_WITH_LEGACY_ACCOUNT,
+            payload: T.VersionedHostCreateTransactionWithLegacyAccountRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostCreateTransactionWithLegacyAccountResponse, T.HostCreateTransactionError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Sign raw bytes with a non-product account. */
+    async signRawWithLegacyAccount(request) {
+        const result = await this.transport.request({
+            ids: W.SIGNING_SIGN_RAW_WITH_LEGACY_ACCOUNT,
+            payload: T.VersionedHostSignRawWithLegacyAccountRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostSignPayloadResponse, T.HostSignPayloadError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Sign an extrinsic payload with a non-product account. */
+    async signPayloadWithLegacyAccount(request) {
+        const result = await this.transport.request({
+            ids: W.SIGNING_SIGN_PAYLOAD_WITH_LEGACY_ACCOUNT,
+            payload: T.VersionedHostSignPayloadWithLegacyAccountRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostSignPayloadResponse, T.HostSignPayloadError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Sign raw bytes or a message. */
+    async signRaw(request) {
+        const result = await this.transport.request({
+            ids: W.SIGNING_SIGN_RAW,
+            payload: T.VersionedHostSignRawRequest.enc({ tag: "V1", value: request }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostSignPayloadResponse, T.HostSignPayloadError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Sign an extrinsic payload. */
+    async signPayload(request) {
+        const result = await this.transport.request({
+            ids: W.SIGNING_SIGN_PAYLOAD,
+            payload: T.VersionedHostSignPayloadRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostSignPayloadResponse, T.HostSignPayloadError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Statement store methods. */
+export class StatementStoreClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Subscribe to statements matching a topic filter. */
+    subscribe({ request, }) {
+        return createObservable({
+            transport: this.transport,
+            ids: W.STATEMENT_STORE_SUBSCRIBE,
+            payload: T.VersionedRemoteStatementStoreSubscribeRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeItem: (payload) => T.VersionedRemoteStatementStoreSubscribeItem.dec(payload).value,
+        });
+    }
+    /** Create a proof for a statement. */
+    async createProof(request) {
+        const result = await this.transport.request({
+            ids: W.STATEMENT_STORE_CREATE_PROOF,
+            payload: T.VersionedRemoteStatementStoreCreateProofRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteStatementStoreCreateProofResponse, T.RemoteStatementStoreCreateProofError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /**
+     * Create a proof for a statement using a pre-allocated allowance account,
+     * bypassing the per-call signing prompt.
+     */
+    async createProofAuthorized(request) {
+        const result = await this.transport.request({
+            ids: W.STATEMENT_STORE_CREATE_PROOF_AUTHORIZED,
+            payload: T.VersionedRemoteStatementStoreCreateProofAuthorizedRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.RemoteStatementStoreCreateProofResponse, T.RemoteStatementStoreCreateProofError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /**
+     * Submit a signed statement to the network. The request body is the
+     * [`SignedStatement`](crate::v01::SignedStatement) directly (no wrapping
+     * struct), matching upstream `triangle-js-sdks`.
+     */
+    async submit(request) {
+        const result = await this.transport.request({
+            ids: W.STATEMENT_STORE_SUBMIT,
+            payload: T.VersionedRemoteStatementStoreSubmitRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.GenericError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/**
+ * General-purpose TrUAPI methods for handshake, feature detection,
+ * navigation, and notifications.
+ */
+export class SystemClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Negotiate the wire codec version with the product. */
+    async handshake() {
+        const result = await this.transport.request({
+            ids: W.SYSTEM_HANDSHAKE,
+            payload: T.VersionedHostHandshakeRequest.enc({
+                tag: "V1",
+                value: { codecVersion: this.transport.codecVersion },
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.HostHandshakeError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Query whether the host supports a specific feature. */
+    async featureSupported(request) {
+        const result = await this.transport.request({
+            ids: W.SYSTEM_FEATURE_SUPPORTED,
+            payload: T.VersionedHostFeatureSupportedRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [
+                    0,
+                    S.Result(T.HostFeatureSupportedResponse, T.GenericError),
+                ],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Send a push notification to the user. */
+    async pushNotification(request) {
+        const result = await this.transport.request({
+            ids: W.SYSTEM_PUSH_NOTIFICATION,
+            payload: T.VersionedHostPushNotificationRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.GenericError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+    /** Request the host to open a URL. */
+    async navigateTo(request) {
+        const result = await this.transport.request({
+            ids: W.SYSTEM_NAVIGATE_TO,
+            payload: T.VersionedHostNavigateToRequest.enc({
+                tag: "V1",
+                value: request,
+            }),
+            decodeResponse: (payload) => S.indexedTaggedUnion({
+                V1: [0, S.Result(S._void, T.HostNavigateToError)],
+            }).dec(payload).value,
+        });
+        return result.success ? ok(result.value) : err(result.value);
+    }
+}
+/** Host theme subscription. */
+export class ThemeClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Subscribe to host theme changes. */
+    subscribe() {
+        return createObservable({
+            transport: this.transport,
+            ids: W.THEME_SUBSCRIBE,
+            payload: S.indexedTaggedUnion({ V1: [0, S._void] }).enc({
+                tag: "V1",
+                value: undefined,
+            }),
+            decodeItem: (payload) => T.VersionedHostThemeSubscribeItem.dec(payload).value,
+        });
+    }
+}
+function withGeneratedTransportVersions(transport) {
+    return {
+        ...transport,
+        truapiVersion: transport.truapiVersion ?? TRUAPI_VERSION,
+        codecVersion: transport.codecVersion ?? TRUAPI_CODEC_VERSION,
+    };
+}
+/** Creates the generated client facade by binding each service namespace to the
+ * shared transport instance. */
+export function createClient(transport) {
+    const versionedTransport = withGeneratedTransportVersions(transport);
+    return {
+        account: new AccountClient(versionedTransport),
+        chain: new ChainClient(versionedTransport),
+        chat: new ChatClient(versionedTransport),
+        entropy: new EntropyClient(versionedTransport),
+        jsonRpc: new JsonRpcClient(versionedTransport),
+        localStorage: new LocalStorageClient(versionedTransport),
+        payment: new PaymentClient(versionedTransport),
+        permissions: new PermissionsClient(versionedTransport),
+        preimage: new PreimageClient(versionedTransport),
+        resourceAllocation: new ResourceAllocationClient(versionedTransport),
+        signing: new SigningClient(versionedTransport),
+        statementStore: new StatementStoreClient(versionedTransport),
+        system: new SystemClient(versionedTransport),
+        theme: new ThemeClient(versionedTransport),
+    };
+}