@parity/truapi 0.1.0

package/dist/generated/client.d.ts

@@ -0,0 +1,243 @@
+import { type Result } from "neverthrow";
+import type { HexString } from "../scale.js";
+import { SubscriptionError } from "../transport.js";
+import type { ObservableLike, Observer, Subscription, TrUApiTransport } from "../transport.js";
+import * as T from "./types.js";
+export { Result, SubscriptionError };
+export type { ObservableLike, Observer, Subscription, TrUApiTransport };
+export declare const TRUAPI_VERSION: 1;
+export declare const TRUAPI_CODEC_VERSION: 1;
+/** Account lookup, aliasing, and proof generation. */
+export declare class AccountClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to account connection status changes. */
+    connectionStatusSubscribe(): ObservableLike<T.HostAccountConnectionStatusSubscribeItem>;
+    /** Retrieve a product-scoped account. */
+    getAccount(request: T.HostAccountGetRequest): Promise<Result<T.HostAccountGetResponse, T.HostAccountGetError>>;
+    /** Retrieve a contextual alias for a product account. */
+    getAccountAlias(request: T.HostAccountGetAliasRequest): Promise<Result<T.HostAccountGetAliasResponse, T.HostAccountGetError>>;
+    /** Generate a ring VRF proof for a product account. */
+    createAccountProof(request: T.HostAccountCreateProofRequest): Promise<Result<T.HostAccountCreateProofResponse, T.HostAccountCreateProofError>>;
+    /** List non-product accounts the user owns. */
+    getLegacyAccounts(): Promise<Result<T.HostGetLegacyAccountsResponse, T.HostAccountGetError>>;
+    /** Fetch the user's primary identity. */
+    getUserId(): Promise<Result<T.HostGetUserIdResponse, T.HostGetUserIdError>>;
+    /**
+     * 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.
+     */
+    requestLogin(request: T.HostRequestLoginRequest): Promise<Result<T.HostRequestLoginResponse, T.HostRequestLoginError>>;
+}
+/** Chain interaction methods. */
+export declare class ChainClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Follow the chain head and receive block events. */
+    followHeadSubscribe({ request, }: {
+        request: T.RemoteChainHeadFollowRequest;
+    }): ObservableLike<T.RemoteChainHeadFollowItem>;
+    /** Fetch a block header. */
+    getHeadHeader(request: T.RemoteChainHeadHeaderRequest): Promise<Result<T.RemoteChainHeadHeaderResponse, T.GenericError>>;
+    /** Fetch a block body. */
+    getHeadBody(request: T.RemoteChainHeadBodyRequest): Promise<Result<T.RemoteChainHeadBodyResponse, T.GenericError>>;
+    /** Query runtime storage at a specific block. */
+    getHeadStorage(request: T.RemoteChainHeadStorageRequest): Promise<Result<T.RemoteChainHeadStorageResponse, T.GenericError>>;
+    /** Invoke a runtime call at a specific block. */
+    callHead(request: T.RemoteChainHeadCallRequest): Promise<Result<T.RemoteChainHeadCallResponse, T.GenericError>>;
+    /** Release pinned blocks. */
+    unpinHead(request: T.RemoteChainHeadUnpinRequest): Promise<Result<undefined, T.GenericError>>;
+    /** Continue a paused chain-head operation. */
+    continueHead(request: T.RemoteChainHeadContinueRequest): Promise<Result<undefined, T.GenericError>>;
+    /** Stop a chain-head operation. */
+    stopHeadOperation(request: T.RemoteChainHeadStopOperationRequest): Promise<Result<undefined, T.GenericError>>;
+    /** Fetch the canonical genesis hash for a chain. */
+    getSpecGenesisHash(request: T.RemoteChainSpecGenesisHashRequest): Promise<Result<T.RemoteChainSpecGenesisHashResponse, T.GenericError>>;
+    /** Fetch the display name of a chain. */
+    getSpecChainName(request: T.RemoteChainSpecChainNameRequest): Promise<Result<T.RemoteChainSpecChainNameResponse, T.GenericError>>;
+    /** Fetch the JSON-encoded properties of a chain. */
+    getSpecProperties(request: T.RemoteChainSpecPropertiesRequest): Promise<Result<T.RemoteChainSpecPropertiesResponse, T.GenericError>>;
+    /** Broadcast a signed transaction. */
+    broadcastTransaction(request: T.RemoteChainTransactionBroadcastRequest): Promise<Result<T.RemoteChainTransactionBroadcastResponse, T.GenericError>>;
+    /** Stop a transaction broadcast. */
+    stopTransaction(request: T.RemoteChainTransactionStopRequest): Promise<Result<undefined, T.GenericError>>;
+}
+/** Chat room, bot, and message APIs. */
+export declare class ChatClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Create a chat room. */
+    createRoom(request: T.HostChatCreateRoomRequest): Promise<Result<T.HostChatCreateRoomResponse, T.HostChatCreateRoomError>>;
+    /** Register a chat bot. */
+    registerBot(request: T.HostChatRegisterBotRequest): Promise<Result<T.HostChatRegisterBotResponse, T.HostChatRegisterBotError>>;
+    /** Subscribe to the list of chat rooms. */
+    listSubscribe(): ObservableLike<T.HostChatListSubscribeItem>;
+    /** Post a message to a chat room. */
+    postMessage(request: T.HostChatPostMessageRequest): Promise<Result<T.HostChatPostMessageResponse, T.HostChatPostMessageError>>;
+    /** Subscribe to received chat actions. */
+    actionSubscribe(): ObservableLike<T.HostChatActionSubscribeItem>;
+    /**
+     * 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, }: {
+        request: T.ProductChatCustomMessageRenderSubscribeRequest;
+    }): ObservableLike<T.CustomRendererNode>;
+}
+/** Deterministic entropy derivation. */
+export declare class EntropyClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Derive deterministic entropy. */
+    derive(request: T.HostDeriveEntropyRequest): Promise<Result<T.HostDeriveEntropyResponse, T.HostDeriveEntropyError>>;
+}
+/** JSON-RPC transport methods. */
+export declare class JsonRpcClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Send a JSON-RPC message. */
+    sendMessage(request: T.HostJsonrpcMessageSendRequest): Promise<Result<undefined, T.GenericError>>;
+    /** Subscribe to inbound JSON-RPC messages. */
+    subscribeMessages({ request, }: {
+        request: T.HostJsonrpcMessageSubscribeRequest;
+    }): ObservableLike<T.HostJsonrpcMessageSubscribeItem>;
+}
+/** Local key/value storage scoped to the calling product. */
+export declare class LocalStorageClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Read a value by key. */
+    read(request: T.HostLocalStorageReadRequest): Promise<Result<T.HostLocalStorageReadResponse, T.HostLocalStorageReadError>>;
+    /** Write a value to a key. */
+    write(request: T.HostLocalStorageWriteRequest): Promise<Result<undefined, T.HostLocalStorageReadError>>;
+    /** Clear a value by key. */
+    clear(request: T.HostLocalStorageClearRequest): Promise<Result<undefined, T.HostLocalStorageReadError>>;
+}
+/** Payment request and balance/status subscription methods. */
+export declare class PaymentClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to payment balance updates. */
+    balanceSubscribe(): ObservableLike<T.HostPaymentBalanceSubscribeItem, T.HostPaymentBalanceSubscribeError>;
+    /** Request a payment from the user. */
+    request(request: T.HostPaymentRequestRequest): Promise<Result<T.HostPaymentRequestResponse, T.HostPaymentRequestError>>;
+    /** Subscribe to payment lifecycle updates for a specific payment. */
+    statusSubscribe({ request, }: {
+        request: T.HostPaymentStatusSubscribeRequest;
+    }): ObservableLike<T.HostPaymentStatusSubscribeItem, T.HostPaymentStatusSubscribeError>;
+    /** Top up the user's payment balance. */
+    topUp(request: T.HostPaymentTopUpRequest): Promise<Result<undefined, T.HostPaymentTopUpError>>;
+}
+/** Permission request methods. */
+export declare class PermissionsClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Request a device-capability permission from the user. */
+    requestDevicePermission(request: T.HostDevicePermissionRequest): Promise<Result<T.HostDevicePermissionResponse, T.GenericError>>;
+    /** Request one or more remote-operation permissions. */
+    requestRemotePermission(request: T.RemotePermissionRequest): Promise<Result<T.RemotePermissionResponse, T.GenericError>>;
+}
+/** Preimage lookup and submission methods. */
+export declare class PreimageClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to preimage lookups for a given key. */
+    lookupSubscribe({ request, }: {
+        request: T.RemotePreimageLookupSubscribeRequest;
+    }): ObservableLike<T.RemotePreimageLookupSubscribeItem>;
+    /** Submit a preimage. Returns the preimage key (hash) on success. */
+    submit(request: HexString): Promise<Result<HexString, T.PreimageSubmitError>>;
+}
+/** Resource pre-allocation (allowance management). */
+export declare class ResourceAllocationClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Request the host to pre-allocate one or more resources. */
+    request(request: T.HostRequestResourceAllocationRequest): Promise<Result<T.HostRequestResourceAllocationResponse, T.ResourceAllocationError>>;
+}
+/** Signing operations. */
+export declare class SigningClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Construct a signed transaction for a product account. */
+    createTransaction(request: T.HostCreateTransactionRequest): Promise<Result<T.HostCreateTransactionResponse, T.HostCreateTransactionError>>;
+    /** Construct a signed transaction for a non-product account. */
+    createTransactionWithLegacyAccount(request: T.HostCreateTransactionWithLegacyAccountRequest): Promise<Result<T.HostCreateTransactionWithLegacyAccountResponse, T.HostCreateTransactionError>>;
+    /** Sign raw bytes with a non-product account. */
+    signRawWithLegacyAccount(request: T.HostSignRawWithLegacyAccountRequest): Promise<Result<T.HostSignPayloadResponse, T.HostSignPayloadError>>;
+    /** Sign an extrinsic payload with a non-product account. */
+    signPayloadWithLegacyAccount(request: T.HostSignPayloadWithLegacyAccountRequest): Promise<Result<T.HostSignPayloadResponse, T.HostSignPayloadError>>;
+    /** Sign raw bytes or a message. */
+    signRaw(request: T.HostSignRawRequest): Promise<Result<T.HostSignPayloadResponse, T.HostSignPayloadError>>;
+    /** Sign an extrinsic payload. */
+    signPayload(request: T.HostSignPayloadRequest): Promise<Result<T.HostSignPayloadResponse, T.HostSignPayloadError>>;
+}
+/** Statement store methods. */
+export declare class StatementStoreClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to statements matching a topic filter. */
+    subscribe({ request, }: {
+        request: T.RemoteStatementStoreSubscribeRequest;
+    }): ObservableLike<T.RemoteStatementStoreSubscribeItem>;
+    /** Create a proof for a statement. */
+    createProof(request: T.RemoteStatementStoreCreateProofRequest): Promise<Result<T.RemoteStatementStoreCreateProofResponse, T.RemoteStatementStoreCreateProofError>>;
+    /**
+     * Create a proof for a statement using a pre-allocated allowance account,
+     * bypassing the per-call signing prompt.
+     */
+    createProofAuthorized(request: T.Statement): Promise<Result<T.RemoteStatementStoreCreateProofResponse, T.RemoteStatementStoreCreateProofError>>;
+    /**
+     * 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`.
+     */
+    submit(request: T.SignedStatement): Promise<Result<undefined, T.GenericError>>;
+}
+/**
+ * General-purpose TrUAPI methods for handshake, feature detection,
+ * navigation, and notifications.
+ */
+export declare class SystemClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Negotiate the wire codec version with the product. */
+    handshake(): Promise<Result<undefined, T.HostHandshakeError>>;
+    /** Query whether the host supports a specific feature. */
+    featureSupported(request: T.HostFeatureSupportedRequest): Promise<Result<T.HostFeatureSupportedResponse, T.GenericError>>;
+    /** Send a push notification to the user. */
+    pushNotification(request: T.HostPushNotificationRequest): Promise<Result<undefined, T.GenericError>>;
+    /** Request the host to open a URL. */
+    navigateTo(request: T.HostNavigateToRequest): Promise<Result<undefined, T.HostNavigateToError>>;
+}
+/** Host theme subscription. */
+export declare class ThemeClient {
+    private readonly transport;
+    constructor(transport: TrUApiTransport);
+    /** Subscribe to host theme changes. */
+    subscribe(): ObservableLike<T.HostThemeSubscribeItem>;
+}
+export interface TrUApiClient {
+    readonly account: AccountClient;
+    readonly chain: ChainClient;
+    readonly chat: ChatClient;
+    readonly entropy: EntropyClient;
+    readonly jsonRpc: JsonRpcClient;
+    readonly localStorage: LocalStorageClient;
+    readonly payment: PaymentClient;
+    readonly permissions: PermissionsClient;
+    readonly preimage: PreimageClient;
+    readonly resourceAllocation: ResourceAllocationClient;
+    readonly signing: SigningClient;
+    readonly statementStore: StatementStoreClient;
+    readonly system: SystemClient;
+    readonly theme: ThemeClient;
+}
+export type Client = TrUApiClient;
+export type GeneratedClientTransport = Omit<TrUApiTransport, "truapiVersion" | "codecVersion"> & Partial<Pick<TrUApiTransport, "truapiVersion" | "codecVersion">>;
+/** Creates the generated client facade by binding each service namespace to the
+ * shared transport instance. */
+export declare function createClient(transport: GeneratedClientTransport): TrUApiClient;