@novasamatech/host-api-wrapper 0.7.9-5

package/dist/payments.d.ts

@@ -0,0 +1,35 @@
+import type { CodecType, PaymentBalanceErr, Subscription, Transport } from '@novasamatech/host-api';
+export type PaymentBalance = {
+    available: bigint;
+};
+export type PaymentStatus = {
+    type: 'processing';
+} | {
+    type: 'completed';
+} | {
+    type: 'failed';
+    reason: string;
+};
+export type TopUpSource = {
+    type: 'productAccount';
+    derivationIndex: number;
+} | {
+    type: 'privateKey';
+    key: Uint8Array;
+};
+export declare const createPaymentManager: (transport?: Transport) => {
+    subscribeBalance(callback: (balance: PaymentBalance) => void): Subscription<CodecType<typeof PaymentBalanceErr>>;
+    topUp(amount: bigint, source: TopUpSource): Promise<void>;
+    requestPayment(amount: bigint, destination: Uint8Array): Promise<{
+        id: string;
+    }>;
+    subscribePaymentStatus(id: string, callback: (status: PaymentStatus) => void): Subscription;
+};
+export declare const paymentManager: {
+    subscribeBalance(callback: (balance: PaymentBalance) => void): Subscription<CodecType<typeof PaymentBalanceErr>>;
+    topUp(amount: bigint, source: TopUpSource): Promise<void>;
+    requestPayment(amount: bigint, destination: Uint8Array): Promise<{
+        id: string;
+    }>;
+    subscribePaymentStatus(id: string, callback: (status: PaymentStatus) => void): Subscription;
+};

package/dist/payments.js

@@ -0,0 +1,49 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createPaymentManager = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    const version = 'v1';
+    return {
+        subscribeBalance(callback) {
+            const subscriber = hostApi.paymentBalanceSubscribe(enumValue(version, undefined), payload => {
+                if (payload.tag === version) {
+                    callback(payload.value);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+        topUp(amount, source) {
+            const sourceCodec = source.type === 'productAccount'
+                ? {
+                    tag: 'ProductAccount',
+                    value: source.derivationIndex,
+                }
+                : { tag: 'PrivateKey', value: source.key };
+            return resultToPromise(unwrapVersionedResult(version, hostApi.paymentTopUp(enumValue(version, { amount, source: sourceCodec }))));
+        },
+        requestPayment(amount, destination) {
+            return resultToPromise(unwrapVersionedResult(version, hostApi.paymentRequest(enumValue(version, { amount, destination }))));
+        },
+        subscribePaymentStatus(id, callback) {
+            return hostApi.paymentStatusSubscribe(enumValue(version, id), payload => {
+                if (payload.tag === version) {
+                    const raw = payload.value;
+                    if (raw.tag === 'Processing') {
+                        callback({ type: 'processing' });
+                    }
+                    else if (raw.tag === 'Completed') {
+                        callback({ type: 'completed' });
+                    }
+                    else if (raw.tag === 'Failed') {
+                        callback({ type: 'failed', reason: raw.value });
+                    }
+                }
+            });
+        },
+    };
+};
+export const paymentManager = createPaymentManager();

package/dist/permission.d.ts

@@ -0,0 +1,24 @@
+import { DevicePermission, RemotePermission } from '@novasamatech/host-api';
+import type { CodecType } from 'scale-ts';
+export type DevicePermissionKind = CodecType<typeof DevicePermission>;
+export type RemotePermissionItem = CodecType<typeof RemotePermission>;
+/**
+ * Request a single device permission from the host.
+ * Returns ResultAsync<boolean, GenericError>:
+ *   - ok(true)  — permission granted
+ *   - ok(false) — permission denied by the user
+ *   - err(...)  — transport or encoding error
+ */
+export declare function requestDevicePermission(permission: DevicePermissionKind): import("neverthrow").ResultAsync<boolean, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>;
+/**
+ * Request remote permission from the host.
+ * Returns ResultAsync<boolean, GenericError>:
+ *   - ok(true)  — permission granted
+ *   - ok(false) — permission denied by the user
+ *   - err(...)  — transport or encoding error
+ */
+export declare function requestPermission(permission: RemotePermissionItem): import("neverthrow").ResultAsync<boolean, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>;

package/dist/permission.js

@@ -0,0 +1,28 @@
+import { DevicePermission, RemotePermission, enumValue } from '@novasamatech/host-api';
+import { hostApi } from './hostApi.js';
+/**
+ * Request a single device permission from the host.
+ * Returns ResultAsync<boolean, GenericError>:
+ *   - ok(true)  — permission granted
+ *   - ok(false) — permission denied by the user
+ *   - err(...)  — transport or encoding error
+ */
+export function requestDevicePermission(permission) {
+    return hostApi
+        .devicePermission(enumValue('v1', permission))
+        .map(r => r.value)
+        .mapErr(e => e.value);
+}
+/**
+ * Request remote permission from the host.
+ * Returns ResultAsync<boolean, GenericError>:
+ *   - ok(true)  — permission granted
+ *   - ok(false) — permission denied by the user
+ *   - err(...)  — transport or encoding error
+ */
+export function requestPermission(permission) {
+    return hostApi
+        .permission(enumValue('v1', permission))
+        .map(r => r.value)
+        .mapErr(e => e.value);
+}

package/dist/preimage.d.ts

@@ -0,0 +1,9 @@
+import type { HexString, Subscription } from '@novasamatech/host-api';
+export declare const createPreimageManager: (transport?: import("@novasamatech/host-api").Transport) => {
+    lookup(key: HexString, callback: (preimage: Uint8Array | null) => void): Subscription<void>;
+    submit(value: Uint8Array): Promise<`0x${string}`>;
+};
+export declare const preimageManager: {
+    lookup(key: HexString, callback: (preimage: Uint8Array | null) => void): Subscription<void>;
+    submit(value: Uint8Array): Promise<`0x${string}`>;
+};

package/dist/preimage.js

@@ -0,0 +1,24 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createPreimageManager = (transport = sandboxTransport) => {
+    const supportedVersion = 'v1';
+    const hostApi = createHostApi(transport);
+    return {
+        lookup(key, callback) {
+            const subscriber = hostApi.preimageLookupSubscribe(enumValue(supportedVersion, key), payload => {
+                if (payload.tag === supportedVersion) {
+                    callback(payload.value);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+        submit(value) {
+            return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.preimageSubmit(enumValue(supportedVersion, value))));
+        },
+    };
+};
+export const preimageManager = createPreimageManager();

package/dist/sandboxTransport.d.ts

@@ -0,0 +1,9 @@
+import type { Provider } from '@novasamatech/host-api';
+declare global {
+    interface Window {
+        __HOST_API_PORT__?: MessagePort;
+        __HOST_WEBVIEW_MARK__?: boolean;
+    }
+}
+export declare const sandboxProvider: Provider;
+export declare const sandboxTransport: import("@novasamatech/host-api").Transport;

package/dist/sandboxTransport.js

@@ -0,0 +1,109 @@
+import { createDefaultLogger, createTransport } from '@novasamatech/host-api';
+function delay(ttl) {
+    return new Promise(resolve => setTimeout(resolve, ttl));
+}
+function getParentWindow() {
+    if (window.top) {
+        return window.top;
+    }
+    throw new Error('No parent window found');
+}
+function isIframe() {
+    try {
+        return window !== window.top;
+    }
+    catch {
+        return false;
+    }
+}
+function isWebview() {
+    try {
+        return window['__HOST_WEBVIEW_MARK__'] === true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getWebviewPort(iteration = 200) {
+    if (iteration === 0) {
+        throw new Error('No webview port found');
+    }
+    if (window['__HOST_API_PORT__']) {
+        return window['__HOST_API_PORT__'];
+    }
+    await delay(100);
+    return getWebviewPort(iteration - 1);
+}
+function isValidIframeMessage(event, sourceEnv, currentEnv) {
+    return (event.source !== currentEnv &&
+        event.source === sourceEnv &&
+        event.data &&
+        event.data.constructor.name === 'Uint8Array');
+}
+function isValidWebviewMessage(event) {
+    return event.data && event.data.constructor.name === 'Uint8Array';
+}
+// Copy into a tight-fitting ArrayBuffer. Required before handing the array across
+// an Electron IPC / structured-clone boundary: structured clone serializes the full
+// underlying ArrayBuffer.
+function detach(view) {
+    const copy = new Uint8Array(view.byteLength);
+    copy.set(view);
+    return copy;
+}
+function createDefaultSdkProvider() {
+    const subscribers = new Set();
+    const handleIframeMessage = (event) => {
+        if (!isValidIframeMessage(event, getParentWindow(), window))
+            return;
+        for (const subscriber of subscribers) {
+            subscriber(event.data);
+        }
+    };
+    const handleWebviewMessage = (event) => {
+        if (!isValidWebviewMessage(event))
+            return;
+        const detached = detach(event.data);
+        for (const subscriber of subscribers) {
+            subscriber(detached);
+        }
+    };
+    if (isIframe()) {
+        window.addEventListener('message', handleIframeMessage);
+    }
+    else if (isWebview()) {
+        getWebviewPort().then(port => (port.onmessage = handleWebviewMessage));
+    }
+    return {
+        logger: createDefaultLogger(),
+        isCorrectEnvironment() {
+            return isIframe() || isWebview();
+        },
+        postMessage(message) {
+            if (isIframe()) {
+                getParentWindow().postMessage(message, '*', [message.buffer]);
+            }
+            else if (isWebview()) {
+                const detached = detach(message);
+                getWebviewPort().then(port => port.postMessage(detached, [detached.buffer]));
+            }
+        },
+        subscribe(callback) {
+            subscribers.add(callback);
+            return () => {
+                subscribers.delete(callback);
+            };
+        },
+        dispose() {
+            subscribers.clear();
+            if (isIframe()) {
+                window.removeEventListener('message', handleIframeMessage);
+            }
+            if (isWebview()) {
+                getWebviewPort().then(port => (port.onmessage = null));
+            }
+        },
+    };
+}
+export const sandboxProvider = createDefaultSdkProvider();
+export const sandboxTransport = createTransport(sandboxProvider);

package/dist/statementStore.d.ts

@@ -0,0 +1,44 @@
+import type { CodecType, ProductAccountId as ProductAccountIdCodec, SignedStatement as SignedStatementCodec, Statement as StatementCodec, Subscription, Topic as TopicCodec, Transport } from '@novasamatech/host-api';
+export type Statement = CodecType<typeof StatementCodec>;
+export type SignedStatement = CodecType<typeof SignedStatementCodec>;
+export type Topic = CodecType<typeof TopicCodec>;
+export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
+export type StatementTopicFilter = {
+    matchAll: Topic[];
+} | {
+    matchAny: Topic[];
+};
+export type StatementsPage = {
+    statements: SignedStatement[];
+    isComplete: boolean;
+};
+export declare const createStatementStore: (transport?: Transport) => {
+    subscribe(filter: StatementTopicFilter, callback: (page: StatementsPage) => void): Subscription<void>;
+    createProof(accountId: ProductAccountId, statement: Statement): Promise<{
+        tag: "Sr25519";
+        value: {
+            signature: Uint8Array<ArrayBufferLike>;
+            signer: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        tag: "Ed25519";
+        value: {
+            signature: Uint8Array<ArrayBufferLike>;
+            signer: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        tag: "Ecdsa";
+        value: {
+            signature: Uint8Array<ArrayBufferLike>;
+            signer: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        tag: "OnChain";
+        value: {
+            who: Uint8Array<ArrayBufferLike>;
+            blockHash: Uint8Array<ArrayBufferLike>;
+            event: bigint;
+        };
+    }>;
+    submit(signedStatement: SignedStatement): Promise<void>;
+};

package/dist/statementStore.js

@@ -0,0 +1,41 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createStatementStore = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    return {
+        subscribe(filter, callback) {
+            const scaleFilter = 'matchAll' in filter ? enumValue('MatchAll', filter.matchAll) : enumValue('MatchAny', filter.matchAny);
+            const subscriber = hostApi.statementStoreSubscribe(enumValue('v1', scaleFilter), payload => {
+                if (payload.tag === 'v1') {
+                    callback(payload.value);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+        async createProof(accountId, statement) {
+            const result = await hostApi.statementStoreCreateProof(enumValue('v1', [accountId, statement]));
+            return result.match(payload => {
+                if (payload.tag === 'v1') {
+                    return payload.value;
+                }
+                throw new Error(`Unknown response version ${payload.tag}`);
+            }, err => {
+                throw err.value;
+            });
+        },
+        async submit(signedStatement) {
+            const result = await hostApi.statementStoreSubmit(enumValue('v1', signedStatement));
+            return result.match(payload => {
+                if (payload.tag === 'v1') {
+                    return;
+                }
+                throw new Error(`Unknown response version ${payload.tag}`);
+            }, err => {
+                throw err.value;
+            });
+        },
+    };
+};

package/dist/theme.d.ts

@@ -0,0 +1,6 @@
+import type { CodecType, Subscription, Transport } from '@novasamatech/host-api';
+import { Theme } from '@novasamatech/host-api';
+export type ThemeMode = CodecType<typeof Theme>;
+export declare function createThemeProvider(transport?: Transport): {
+    subscribeTheme(callback: (theme: ThemeMode) => void): Subscription<void>;
+};

package/dist/theme.js

@@ -0,0 +1,18 @@
+import { Theme, createHostApi, enumValue } from '@novasamatech/host-api';
+import { sandboxTransport } from './sandboxTransport.js';
+export function createThemeProvider(transport = sandboxTransport) {
+    const hostApi = createHostApi(transport);
+    return {
+        subscribeTheme(callback) {
+            const subscriber = hostApi.themeSubscribe(enumValue('v1', undefined), value => {
+                if (value.tag === 'v1') {
+                    callback(value.value);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+    };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@novasamatech/host-api-wrapper",
+  "type": "module",
+  "version": "0.7.9-5",
+  "description": "Host API wrapper: integrate and run your product inside Polkadot browser.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paritytech/triangle-js-sdks.git"
+  },
+  "keywords": [
+    "polkadot"
+  ],
+  "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "#/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@polkadot/extension-inject": "^0.63.1",
+    "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",
+    "@polkadot-api/substrate-bindings": "^0.20.2",
+    "@novasamatech/host-api": "0.7.9-5",
+    "polkadot-api": ">=2",
+    "neverthrow": "^8.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}