@novasamatech/host-api-wrapper 0.7.9-5

package/dist/accounts.js

@@ -0,0 +1,263 @@
+import { CreateProofErr, GetUserIdErr, LoginErr, RequestCredentialsErr, RingLocation, SigningPayload, SigningPayloadWithoutAccount, SigningRawPayload, SigningRawPayloadWithoutAccount, assertEnumVariant, createHostApi, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
+import { decAnyMetadata, unifyMetadata } from '@polkadot-api/substrate-bindings';
+import { err, ok } from 'neverthrow';
+import { getPolkadotSignerFromPjs } from 'polkadot-api/pjs-signer';
+import { sandboxTransport } from './sandboxTransport.js';
+const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
+export const createAccountsProvider = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    return {
+        getUserId() {
+            return hostApi
+                .getUserId(enumValue('v1', undefined))
+                .mapErr(e => e.value)
+                .andThen(response => {
+                if (isEnumVariant(response, 'v1')) {
+                    return ok(response.value);
+                }
+                // @ts-expect-error response.tag is never here
+                return err(new GetUserIdErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
+        requestLogin(reason) {
+            return hostApi
+                .requestLogin(enumValue('v1', reason))
+                .mapErr(e => e.value)
+                .andThen(response => {
+                if (isEnumVariant(response, 'v1')) {
+                    return ok(response.value);
+                }
+                // @ts-expect-error response.tag is never here
+                return err(new LoginErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
+        getProductAccount(dotNsIdentifier, derivationIndex = 0) {
+            return hostApi
+                .accountGet(enumValue('v1', [dotNsIdentifier, derivationIndex]))
+                .mapErr(e => e.value)
+                .andThen(response => {
+                if (isEnumVariant(response, 'v1')) {
+                    return ok({
+                        publicKey: response.value.publicKey,
+                        dotNsIdentifier,
+                        derivationIndex,
+                    });
+                }
+                // @ts-expect-error response.tag is never here
+                return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
+        getProductAccountAlias(dotNsIdentifier, derivationIndex = 0) {
+            return hostApi
+                .accountGetAlias(enumValue('v1', [dotNsIdentifier, derivationIndex]))
+                .mapErr(e => e.value)
+                .andThen(response => {
+                if (isEnumVariant(response, 'v1')) {
+                    return ok(response.value);
+                }
+                // @ts-expect-error response.tag is never here
+                return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
+        getLegacyAccounts() {
+            return hostApi
+                .getLegacyAccounts(enumValue('v1', undefined))
+                .mapErr(e => e.value)
+                .andThen(response => {
+                if (isEnumVariant(response, 'v1')) {
+                    return ok(response.value);
+                }
+                // @ts-expect-error response.tag is never here
+                return err(new RequestCredentialsErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
+        createRingVRFProof(dotNsIdentifier, derivationIndex = 0, location, message) {
+            return hostApi
+                .accountCreateProof(enumValue('v1', [[dotNsIdentifier, derivationIndex], location, message]))
+                .mapErr(e => e.value)
+                .andThen(response => {
+                if (isEnumVariant(response, 'v1')) {
+                    return ok(response.value);
+                }
+                // @ts-expect-error response.tag is never here
+                return err(new CreateProofErr.Unknown({ reason: `Unsupported response version ${response.tag}` }));
+            });
+        },
+        /**
+         * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
+         *
+         * The factory is async because `PolkadotSigner.publicKey` must be a synchronous
+         * `Uint8Array` on the returned object — it is fetched up front via `host_account_get`.
+         */
+        getProductAccountSigner(account, signerType = 'signPayload') {
+            const hostApi = createHostApi(transport);
+            const productAccountId = [account.dotNsIdentifier, account.derivationIndex];
+            /**
+             * @deprecated added for backward compatibility
+             */
+            if (signerType === 'signPayload') {
+                return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
+                    const codecPayload = {
+                        account: [account.dotNsIdentifier, account.derivationIndex],
+                        payload: buildSigningPayloadFields(payload),
+                    };
+                    const response = await hostApi.signPayload(enumValue('v1', codecPayload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return {
+                            id: 0,
+                            signature: response.value.signature,
+                            signedTransaction: response.value.signedTransaction,
+                        };
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
+                }, async (raw) => {
+                    const payload = {
+                        account: [account.dotNsIdentifier, account.derivationIndex],
+                        payload: raw.type === 'bytes'
+                            ? {
+                                tag: 'Bytes',
+                                value: fromHex(asHex(raw.data)),
+                            }
+                            : {
+                                tag: 'Payload',
+                                value: raw.data,
+                            },
+                    };
+                    const response = await hostApi.signRaw(enumValue('v1', payload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return {
+                            id: 0,
+                            signature: response.value.signature,
+                            signedTransaction: response.value.signedTransaction,
+                        };
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
+                });
+            }
+            return {
+                publicKey: account.publicKey,
+                async signTx(callData, signedExtensions, metadata) {
+                    const decMeta = unifyMetadata(decAnyMetadata(metadata));
+                    const { version: versions } = decMeta.extrinsic;
+                    const latestVersion = versions.reduce((acc, v) => Math.max(acc, v), 0);
+                    const txExtVersion = latestVersion === 4 ? 0 : latestVersion;
+                    const checkGenesis = signedExtensions['CheckGenesis'];
+                    if (!checkGenesis) {
+                        throw new Error("Can't find genesis hash on transaction");
+                    }
+                    const txPayload = {
+                        signer: productAccountId,
+                        genesisHash: checkGenesis.additionalSigned,
+                        callData,
+                        extensions: Object.values(signedExtensions).map(({ identifier, value, additionalSigned }) => ({
+                            id: identifier,
+                            extra: value,
+                            additionalSigned: additionalSigned,
+                        })),
+                        txExtVersion,
+                    };
+                    const response = await hostApi.createTransaction(enumValue('v1', txPayload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return response.value;
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
+                },
+                async signBytes(data) {
+                    const response = await hostApi.signRaw(enumValue('v1', {
+                        account: productAccountId,
+                        payload: { tag: 'Bytes', value: data },
+                    }));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return fromHex(response.value.signature);
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
+                },
+            };
+        },
+        subscribeAccountConnectionStatus(callback) {
+            const subscriber = hostApi.accountConnectionStatusSubscribe(enumValue('v1', undefined), status => {
+                if (status.tag === 'v1') {
+                    callback(status.value);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+        getLegacyAccountSigner(account) {
+            return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
+                const codecPayload = {
+                    signer: payload.address,
+                    payload: buildSigningPayloadFields(payload),
+                };
+                const response = await hostApi.signPayloadWithLegacyAccount(enumValue('v1', codecPayload));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return {
+                        id: 0,
+                        signature: response.value.signature,
+                        signedTransaction: response.value.signedTransaction,
+                    };
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
+            }, async (raw) => {
+                const payload = {
+                    signer: raw.address,
+                    payload: { tag: 'Bytes', value: fromHex(asHex(raw.data)) },
+                };
+                const response = await hostApi.signRawWithLegacyAccount(enumValue('v1', payload));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return {
+                        id: 0,
+                        signature: response.value.signature,
+                        signedTransaction: response.value.signedTransaction,
+                    };
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
+            });
+        },
+    };
+};
+export const accounts = createAccountsProvider();
+function asHex(v) {
+    if (v.startsWith('0x'))
+        return v;
+    return `0x${v}`;
+}
+function buildSigningPayloadFields(payload) {
+    return {
+        blockHash: asHex(payload.blockHash),
+        blockNumber: asHex(payload.blockNumber),
+        era: asHex(payload.era),
+        genesisHash: asHex(payload.genesisHash),
+        nonce: asHex(payload.nonce),
+        method: asHex(payload.method),
+        specVersion: asHex(payload.specVersion),
+        transactionVersion: asHex(payload.transactionVersion),
+        metadataHash: payload.metadataHash ? asHex(payload.metadataHash) : undefined,
+        tip: asHex(payload.tip),
+        assetId: payload.assetId !== undefined ? payload.assetId : undefined,
+        mode: payload.mode,
+        withSignedTransaction: payload.withSignedTransaction,
+        signedExtensions: payload.signedExtensions,
+        version: payload.version,
+    };
+}

package/dist/chat.d.ts

@@ -0,0 +1,33 @@
+import type { ChatBotRegistrationStatus as ChatBotRegistrationStatusCodec, ChatMessageContent as ChatMessageContentCodec, ChatRoom as ChatRoomCodec, ChatRoomRegistrationStatus as ChatRoomRegistrationStatusCodec, CodecType, ReceivedChatAction as ReceivedChatActionCodec, Subscription, Transport } from '@novasamatech/host-api';
+import { CustomRendererNode } from '@novasamatech/host-api';
+export type ChatMessageContent = CodecType<typeof ChatMessageContentCodec>;
+export type ChatReceivedAction = CodecType<typeof ReceivedChatActionCodec>;
+export type ChatRoomRegistrationResult = CodecType<typeof ChatRoomRegistrationStatusCodec>;
+export type ChatBotRegistrationResult = CodecType<typeof ChatBotRegistrationStatusCodec>;
+export type ChatRoom = CodecType<typeof ChatRoomCodec>;
+export type ChatCustomMessageRenderer = (params: ChatCustomMessageRendererParams, render: (node: CodecType<typeof CustomRendererNode>) => void) => VoidFunction;
+export type ChatCustomMessageRendererParams<T = Uint8Array> = {
+    messageId: string;
+    messageType: string;
+    payload: T;
+    subscribeActions(callback: (actionId: string, payload: Uint8Array | undefined) => void): VoidFunction;
+};
+export declare const createProductChatManager: (transport?: Transport) => {
+    registerRoom(params: {
+        roomId: string;
+        name: string;
+        icon: string;
+    }): Promise<"New" | "Exists">;
+    registerBot(params: {
+        botId: string;
+        name: string;
+        icon: string;
+    }): Promise<"New" | "Exists">;
+    sendMessage(roomId: string, payload: ChatMessageContent): Promise<{
+        messageId: string;
+    }>;
+    subscribeChatList(callback: (rooms: ChatRoom[]) => void): Subscription<void>;
+    subscribeAction(callback: (action: ChatReceivedAction) => void): Subscription<void>;
+    onCustomMessageRenderingRequest(callback: ChatCustomMessageRenderer): VoidFunction;
+};
+export declare function matchChatCustomRenderers(map: Record<string, ChatCustomMessageRenderer>): ChatCustomMessageRenderer;

package/dist/chat.js

@@ -0,0 +1,125 @@
+import { CustomRendererNode, createHostApi, enumValue } from '@novasamatech/host-api';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createProductChatManager = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    const roomRegistrationStatus = {};
+    const botRegistrationStatus = {};
+    const chat = {
+        async registerRoom(params) {
+            const existingRegistration = roomRegistrationStatus[params.roomId];
+            if (existingRegistration) {
+                return existingRegistration;
+            }
+            const result = await hostApi.chatCreateRoom(enumValue('v1', params));
+            return result.match(payload => {
+                switch (payload.tag) {
+                    case 'v1': {
+                        roomRegistrationStatus[params.roomId] = payload.value.status;
+                        return payload.value.status;
+                    }
+                    default:
+                        throw new Error(`Unknown message version ${payload.tag}`);
+                }
+            }, err => {
+                throw err.value;
+            });
+        },
+        async registerBot(params) {
+            const existingRegistration = botRegistrationStatus[params.botId];
+            if (existingRegistration) {
+                return existingRegistration;
+            }
+            const result = await hostApi.chatRegisterBot(enumValue('v1', params));
+            return result.match(payload => {
+                switch (payload.tag) {
+                    case 'v1': {
+                        botRegistrationStatus[params.botId] = payload.value.status;
+                        return payload.value.status;
+                    }
+                    default:
+                        throw new Error(`Unknown message version ${payload.tag}`);
+                }
+            }, err => {
+                throw err.value;
+            });
+        },
+        async sendMessage(roomId, payload) {
+            const result = await hostApi.chatPostMessage(enumValue('v1', { roomId, payload }));
+            return result.match(payload => {
+                switch (payload.tag) {
+                    case 'v1': {
+                        return { messageId: payload.value.messageId };
+                    }
+                    default:
+                        throw new Error(`Unknown message version ${payload.tag}`);
+                }
+            }, err => {
+                throw err.value;
+            });
+        },
+        subscribeChatList(callback) {
+            const subscriber = hostApi.chatListSubscribe(enumValue('v1', undefined), action => {
+                if (action.tag === 'v1') {
+                    callback(action.value);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+        subscribeAction(callback) {
+            const subscriber = hostApi.chatActionSubscribe(enumValue('v1', undefined), action => {
+                switch (action.tag) {
+                    case 'v1':
+                        callback(action.value);
+                        break;
+                    default:
+                        console.error(`Unknown message version ${action.tag}`);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+        onCustomMessageRenderingRequest(callback) {
+            return transport.handleSubscription('product_chat_custom_message_render_subscribe', (params, send, interrupt) => {
+                if (params.tag !== 'v1') {
+                    // unsupported version
+                    interrupt(enumValue('v1', undefined));
+                    return () => {
+                        /* empty */
+                    };
+                }
+                const { messageId, messageType, payload } = params.value;
+                return callback({
+                    messageId,
+                    messageType,
+                    payload,
+                    subscribeActions(callback) {
+                        const actionsSubscription = hostApi.chatActionSubscribe(enumValue('v1', undefined), action => {
+                            if (action.tag === 'v1' &&
+                                action.value.payload.tag === 'ActionTriggered' &&
+                                action.value.payload.value.messageId === messageId) {
+                                callback(action.value.payload.value.actionId, action.value.payload.value.payload);
+                            }
+                        });
+                        return actionsSubscription.unsubscribe;
+                    },
+                }, node => send(enumValue('v1', node)));
+            });
+        },
+    };
+    return chat;
+};
+export function matchChatCustomRenderers(map) {
+    return (params, render) => {
+        const { messageType } = params;
+        const renderer = map[messageType];
+        if (!renderer) {
+            throw new Error(`Renderer for message type ${messageType} is not defined`);
+        }
+        return renderer(params, render);
+    };
+}

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const Version: string;
+export declare const SpektrExtensionName = "spektr";
+export declare const WellKnownChain: {
+    readonly polkadotRelay: "0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3";
+    readonly polkadotAssetHub: "0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f";
+    readonly kusamaRelay: "0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe";
+    readonly kusamaAssetHub: "0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a";
+    readonly westendRelay: "0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e";
+    readonly westendAssetHub: "0x67f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9";
+    readonly rococo: "0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e";
+};

package/dist/constants.js

@@ -0,0 +1,12 @@
+import pkg from '../package.json' with { type: 'json' };
+export const Version = pkg.version;
+export const SpektrExtensionName = 'spektr';
+export const WellKnownChain = {
+    polkadotRelay: '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3',
+    polkadotAssetHub: '0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f',
+    kusamaRelay: '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe',
+    kusamaAssetHub: '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a',
+    westendRelay: '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e',
+    westendAssetHub: '0x67f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9',
+    rococo: '0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e',
+};

package/dist/deriveEntropy.d.ts

@@ -0,0 +1,3 @@
+export declare function deriveEntropy(key: Uint8Array): import("neverthrow").ResultAsync<Uint8Array<ArrayBufferLike>, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "DeriveEntropyErr::Unknown">>;

package/dist/deriveEntropy.js

@@ -0,0 +1,8 @@
+import { enumValue } from '@novasamatech/host-api';
+import { hostApi } from './hostApi.js';
+export function deriveEntropy(key) {
+    return hostApi
+        .deriveEntropy(enumValue('v1', key))
+        .map(r => r.value)
+        .mapErr(e => e.value);
+}

package/dist/helpers.d.ts

@@ -0,0 +1,9 @@
+import type { ResultAsync } from 'neverthrow';
+export declare function unwrapVersionedResult<OK, KO, V extends string>(version: V, result: ResultAsync<{
+    tag: V;
+    value: OK;
+}, {
+    tag: V;
+    value: KO;
+}>): ResultAsync<OK, Error | KO>;
+export declare function resultToPromise<T>(result: ResultAsync<T, unknown>): Promise<T>;

package/dist/helpers.js

@@ -0,0 +1,19 @@
+import { err, ok } from 'neverthrow';
+export function unwrapVersionedResult(version, result) {
+    return result
+        .orElse(payload => {
+        if (payload.tag !== version) {
+            return err(new Error(`Unsupported result version ${payload.tag}`));
+        }
+        return err(payload.value);
+    })
+        .andThen(payload => {
+        if (payload.tag !== version) {
+            return err(new Error(`Unsupported result version ${payload.tag}`));
+        }
+        return ok(payload.value);
+    });
+}
+export function resultToPromise(result) {
+    return new Promise((resolve, reject) => result.match(resolve, reject));
+}

package/dist/hostApi.d.ts

@@ -0,0 +1 @@
+export declare const hostApi: import("@novasamatech/host-api").HostApi;

package/dist/hostApi.js

@@ -0,0 +1,3 @@
+import { createHostApi } from '@novasamatech/host-api';
+import { sandboxTransport } from './sandboxTransport.js';
+export const hostApi = createHostApi(sandboxTransport);

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { SpektrExtensionName, WellKnownChain } from './constants.js';
+export { sandboxProvider, sandboxTransport } from './sandboxTransport.js';
+export { hostApi } from './hostApi.js';
+export { createMetaProvider, metaProvider } from './metaProvider.js';
+export { createLegacyExtensionEnableFactory, injectSpektrExtension } from './injectWeb3.js';
+export { createPapiProvider } from './papiProvider.js';
+export type { ChatBotRegistrationResult, ChatCustomMessageRenderer, ChatCustomMessageRendererParams, ChatMessageContent, ChatReceivedAction, ChatRoom, ChatRoomRegistrationResult, } from './chat.js';
+export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
+export type { ProductAccountId, SignedStatement, Statement, StatementTopicFilter, StatementsPage, Topic, } from './statementStore.js';
+export { createStatementStore } from './statementStore.js';
+export type { AccountConnectionStatus, LegacyAccount, ProductAccount } from './accounts.js';
+export { accounts, createAccountsProvider } from './accounts.js';
+export type { ThemeMode } from './theme.js';
+export { createThemeProvider } from './theme.js';
+export { createLocalStorage, hostLocalStorage } from './localStorage.js';
+export type { NotificationId, PushNotificationInput } from './notification.js';
+export { createNotificationManager, notificationManager } from './notification.js';
+export { createPreimageManager, preimageManager } from './preimage.js';
+export type { PaymentBalance, PaymentStatus, TopUpSource } from './payments.js';
+export { createPaymentManager, paymentManager } from './payments.js';
+export { deriveEntropy } from './deriveEntropy.js';
+export type { DevicePermissionKind, RemotePermissionItem } from './permission.js';
+export { requestDevicePermission, requestPermission } from './permission.js';

package/dist/index.js

@@ -0,0 +1,16 @@
+export { SpektrExtensionName, WellKnownChain } from './constants.js';
+export { sandboxProvider, sandboxTransport } from './sandboxTransport.js';
+export { hostApi } from './hostApi.js';
+export { createMetaProvider, metaProvider } from './metaProvider.js';
+export { createLegacyExtensionEnableFactory, injectSpektrExtension } from './injectWeb3.js';
+export { createPapiProvider } from './papiProvider.js';
+export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
+export { createStatementStore } from './statementStore.js';
+export { accounts, createAccountsProvider } from './accounts.js';
+export { createThemeProvider } from './theme.js';
+export { createLocalStorage, hostLocalStorage } from './localStorage.js';
+export { createNotificationManager, notificationManager } from './notification.js';
+export { createPreimageManager, preimageManager } from './preimage.js';
+export { createPaymentManager, paymentManager } from './payments.js';
+export { deriveEntropy } from './deriveEntropy.js';
+export { requestDevicePermission, requestPermission } from './permission.js';

package/dist/injectWeb3.d.ts

@@ -0,0 +1,90 @@
+import type { HexString, Transport } from '@novasamatech/host-api';
+import type { InjectedAccounts } from '@polkadot/extension-inject/types';
+import type { SignerPayloadJSON, SignerPayloadRaw, SignerResult } from '@polkadot/types/types/extrinsic';
+/**
+ * expected interface derived from specification
+ */
+export interface TxPayloadV1 {
+    /** Payload version. MUST be 1. */
+    version: 1;
+    /**
+     * Signer selection hint. Allows the implementer to identify which private-key / scheme to use.
+     * - Use a wallet-defined handle (e.g., address/SS58, account-name, etc). This identifier
+     * was previously made available to the consumer.
+     * - Set `null` to let the implementer pick the signer (or if the signer is implied).
+     */
+    signer: string | null;
+    /**
+     * SCALE-encoded Call (module indicator + function indicator + params).
+     */
+    callData: HexString;
+    /**
+     * Transaction extensions supplied by the caller (order irrelevant).
+     * The consumer SHOULD provide every extension that is relevant to them.
+     * The implementer MAY infer missing ones.
+     */
+    extensions: Array<{
+        /** Identifier as defined in metadata (e.g., "CheckSpecVersion", "ChargeAssetTxPayment"). */
+        id: string;
+        /**
+         * Explicit "extra" to sign (goes into the extrinsic body).
+         * SCALE-encoded per the extension's "extra" type as defined in the metadata.
+         */
+        extra: HexString;
+        /**
+         * "Implicit" data to sign (known by the chain, not included into the extrinsic body).
+         * SCALE-encoded per the extension's "additionalSigned" type as defined in the metadata.
+         */
+        additionalSigned: HexString;
+    }>;
+    /**
+     * Transaction Extension Version.
+     * - For Extrinsic V4 MUST be 0.
+     * - For Extrinsic V5, set to any version supported by the runtime.
+     * The implementer:
+     *  - MUST use this field to determine the required extensions for creating the extrinsic.
+     *  - MAY use this field to infer missing extensions that the implementer could know how to handle.
+     */
+    txExtVersion: number;
+    /**
+     * Context needed for decoding, display, and (optionally) inferring certain extensions.
+     */
+    context: {
+        /**
+         * RuntimeMetadataPrefixed blob (SCALE), starting with ASCII "meta" magic (`0x6d657461`),
+         * then a metadata version (V14+). For V5+ versioned extensions, MUST provide V16+.
+         */
+        metadata: HexString;
+        /**
+         * Native token display info (used by some implementers), also needed to compute
+         * the `CheckMetadataHash` value.
+         */
+        tokenSymbol: string;
+        tokenDecimals: number;
+        /**
+         * Highest known block number to aid mortality UX.
+         */
+        bestBlockHeight: number;
+    };
+}
+interface Signer {
+    /**
+     * @description signs an extrinsic payload from a serialized form
+     */
+    signPayload?: (payload: SignerPayloadJSON) => Promise<SignerResult>;
+    /**
+     * @description signs a raw payload, only the bytes data as supplied
+     */
+    signRaw?: (raw: SignerPayloadRaw) => Promise<SignerResult>;
+    /**
+     * @description signs a transaction according to https://github.com/polkadot-js/api/issues/6213
+     */
+    createTransaction?: (payload: TxPayloadV1) => Promise<HexString>;
+}
+interface Injected {
+    accounts: InjectedAccounts;
+    signer: Signer;
+}
+export declare function createLegacyExtensionEnableFactory(transport: Transport): Promise<(() => Promise<Injected>) | null>;
+export declare function injectSpektrExtension(transport?: Transport | null): Promise<boolean>;
+export {};