@novasamatech/host-api 0.5.0-9 → 0.5.1

package/dist/protocol/v1/sign.d.ts

@@ -0,0 +1,152 @@
+export declare const SigningErr: [import("scale-ts").Encoder<(Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "SigningErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "SigningErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "SigningErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "SigningErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "SigningErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "SigningErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly FailedToDecode: import("../commonCodecs.js").ErrCodec<undefined, "SigningErr::FailedToDecode">;
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "SigningErr::Rejected">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "SigningErr::Unknown">;
+};
+export declare const SigningResult: import("scale-ts").Codec<{
+    signature: `0x${string}`;
+    signedTransaction: `0x${string}` | undefined;
+}>;
+export declare const SignRawV1_request: import("scale-ts").Codec<{
+    address: string;
+    data: {
+        tag: "Bytes";
+        value: Uint8Array<ArrayBufferLike>;
+    } | {
+        tag: "Payload";
+        value: string;
+    };
+}>;
+export declare const SignRawV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    signature: `0x${string}`;
+    signedTransaction: `0x${string}` | undefined;
+}, (Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>>;
+export declare const SigningPayload: import("scale-ts").Codec<{
+    address: string;
+    blockHash: `0x${string}`;
+    blockNumber: `0x${string}`;
+    era: `0x${string}`;
+    genesisHash: `0x${string}`;
+    method: `0x${string}`;
+    nonce: `0x${string}`;
+    specVersion: `0x${string}`;
+    tip: `0x${string}`;
+    transactionVersion: `0x${string}`;
+    signedExtensions: string[];
+    version: number;
+    assetId: `0x${string}` | undefined;
+    metadataHash: `0x${string}` | undefined;
+    mode: number | undefined;
+    withSignedTransaction: boolean | undefined;
+}>;
+export declare const SignPayloadV1_request: import("scale-ts").Codec<{
+    address: string;
+    blockHash: `0x${string}`;
+    blockNumber: `0x${string}`;
+    era: `0x${string}`;
+    genesisHash: `0x${string}`;
+    method: `0x${string}`;
+    nonce: `0x${string}`;
+    specVersion: `0x${string}`;
+    tip: `0x${string}`;
+    transactionVersion: `0x${string}`;
+    signedExtensions: string[];
+    version: number;
+    assetId: `0x${string}` | undefined;
+    metadataHash: `0x${string}` | undefined;
+    mode: number | undefined;
+    withSignedTransaction: boolean | undefined;
+}>;
+export declare const SignPayloadV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    signature: `0x${string}`;
+    signedTransaction: `0x${string}` | undefined;
+}, (Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/protocol/v1/sign.js

@@ -0,0 +1,43 @@
+import { Bytes, Option, Result, Struct, Vector, _void, bool, str, u32 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, GenesisHash, Hex } from '../commonCodecs.js';
+// common structures
+export const SigningErr = ErrEnum('SigningErr', {
+    FailedToDecode: [_void, 'Signing: failed to decode'],
+    Rejected: [_void, 'Signing: rejected'],
+    Unknown: [GenericErr, 'Signing: unknown error'],
+});
+export const SigningResult = Struct({
+    signature: Hex(),
+    signedTransaction: Option(Hex()),
+});
+// sign raw
+const SigningRawPayload = Struct({
+    address: str,
+    data: Enum({
+        Bytes: Bytes(),
+        Payload: str,
+    }),
+});
+export const SignRawV1_request = SigningRawPayload;
+export const SignRawV1_response = Result(SigningResult, SigningErr);
+// sign payload
+export const SigningPayload = Struct({
+    address: str,
+    blockHash: Hex(),
+    blockNumber: Hex(),
+    era: Hex(),
+    genesisHash: GenesisHash,
+    method: Hex(),
+    nonce: Hex(),
+    specVersion: Hex(),
+    tip: Hex(),
+    transactionVersion: Hex(),
+    signedExtensions: Vector(str),
+    version: u32,
+    assetId: Option(Hex()),
+    metadataHash: Option(Hex()),
+    mode: Option(u32),
+    withSignedTransaction: Option(bool),
+});
+export const SignPayloadV1_request = SigningPayload;
+export const SignPayloadV1_response = Result(SigningResult, SigningErr);

package/dist/protocol/v1/statementStore.d.ts

@@ -0,0 +1,175 @@
+export declare const Topic: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const Channel: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const DecryptionKey: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const Statement: import("scale-ts").Codec<{
+    proof: {
+        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;
+        };
+    } | undefined;
+    decryptionKey: Uint8Array<ArrayBufferLike> | undefined;
+    priority: number | undefined;
+    channel: Uint8Array<ArrayBufferLike> | undefined;
+    topics: Uint8Array<ArrayBufferLike>[];
+    data: Uint8Array<ArrayBufferLike> | undefined;
+}>;
+export declare const StatementProofErr: [import("scale-ts").Encoder<(Error & {
+    name: "StatementProofErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StatementProofErr::UnableToSign";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "StatementProofErr::UnknownAccount";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "StatementProofErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StatementProofErr::UnableToSign";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "StatementProofErr::UnknownAccount";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "StatementProofErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StatementProofErr::UnableToSign";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "StatementProofErr::UnknownAccount";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "StatementProofErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StatementProofErr::UnableToSign";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "StatementProofErr::UnknownAccount";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly UnableToSign: import("../commonCodecs.js").ErrCodec<undefined, "StatementProofErr::UnableToSign">;
+    readonly UnknownAccount: import("../commonCodecs.js").ErrCodec<undefined, "StatementProofErr::UnknownAccount">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "StatementProofErr::Unknown">;
+};
+export declare const StatementStoreCreateProofV1_request: import("scale-ts").Codec<[[string, number], {
+    proof: {
+        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;
+        };
+    } | undefined;
+    decryptionKey: Uint8Array<ArrayBufferLike> | undefined;
+    priority: number | undefined;
+    channel: Uint8Array<ArrayBufferLike> | undefined;
+    topics: Uint8Array<ArrayBufferLike>[];
+    data: Uint8Array<ArrayBufferLike> | undefined;
+}]>;
+export declare const StatementStoreCreateProofV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    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;
+    };
+}, (Error & {
+    name: "StatementProofErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StatementProofErr::UnableToSign";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "StatementProofErr::UnknownAccount";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/protocol/v1/statementStore.js

@@ -0,0 +1,47 @@
+import { Bytes, Option, Result, Struct, Tuple, Vector, _void, u32, u64 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr } from '../commonCodecs.js';
+import { ProductAccountId } from './accounts.js';
+// structs definition
+export const Topic = Bytes(32);
+export const Channel = Bytes(32);
+export const DecryptionKey = Bytes(32);
+// Proof structures
+const Sr25519StatementProof = Struct({
+    signature: Bytes(64),
+    signer: Bytes(32),
+});
+const Ed25519StatementProof = Struct({
+    signature: Bytes(64),
+    signer: Bytes(32),
+});
+const EcdsaStatementProof = Struct({
+    signature: Bytes(65),
+    signer: Bytes(33),
+});
+const OnChainStatementProof = Struct({
+    who: Bytes(32),
+    blockHash: Bytes(32),
+    event: u64,
+});
+const StatementProof = Enum({
+    Sr25519: Sr25519StatementProof,
+    Ed25519: Ed25519StatementProof,
+    Ecdsa: EcdsaStatementProof,
+    OnChain: OnChainStatementProof,
+});
+export const Statement = Struct({
+    proof: Option(StatementProof),
+    decryptionKey: Option(DecryptionKey),
+    priority: Option(u32),
+    channel: Option(Channel),
+    topics: Vector(Topic),
+    data: Option(Bytes()),
+});
+// creating proof
+export const StatementProofErr = ErrEnum('StatementProofErr', {
+    UnableToSign: [_void, 'StatementProof: unable to sign'],
+    UnknownAccount: [_void, 'StatementProof: unknown account'],
+    Unknown: [GenericErr, 'StatementProof: unknown error'],
+});
+export const StatementStoreCreateProofV1_request = Tuple(ProductAccountId, Statement);
+export const StatementStoreCreateProofV1_response = Result(StatementProof, StatementProofErr);

package/dist/protocol/v1/storage.d.ts

@@ -0,0 +1,87 @@
+export declare const StorageErr: [import("scale-ts").Encoder<(Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "StorageErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StorageErr::Full";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "StorageErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StorageErr::Full";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly Full: import("../commonCodecs.js").ErrCodec<undefined, "StorageErr::Full">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "StorageErr::Unknown">;
+};
+export declare const StorageKey: import("scale-ts").Codec<`0x${string}`>;
+export declare const StorageValue: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const StorageReadV1_request: import("scale-ts").Codec<`0x${string}`>;
+export declare const StorageReadV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike> | undefined, (Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>>;
+export declare const StorageWriteV1_request: import("scale-ts").Codec<[`0x${string}`, Uint8Array<ArrayBufferLike>]>;
+export declare const StorageWriteV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>>;
+export declare const StorageClearV1_request: import("scale-ts").Codec<`0x${string}`>;
+export declare const StorageClearV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/protocol/v1/storage.js

@@ -0,0 +1,16 @@
+import { Bytes, Option, Result, Tuple, _void } from 'scale-ts';
+import { ErrEnum, GenericErr, Hex } from '../commonCodecs.js';
+// common structures
+export const StorageErr = ErrEnum('StorageErr', {
+    Full: [_void, 'Storage is full'],
+    Unknown: [GenericErr, 'Storage: unknown error'],
+});
+export const StorageKey = Hex();
+export const StorageValue = Bytes();
+// actions
+export const StorageReadV1_request = StorageKey;
+export const StorageReadV1_response = Result(Option(StorageValue), StorageErr);
+export const StorageWriteV1_request = Tuple(StorageKey, StorageValue);
+export const StorageWriteV1_response = Result(_void, StorageErr);
+export const StorageClearV1_request = StorageKey;
+export const StorageClearV1_response = Result(_void, StorageErr);

package/dist/provider.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from './types.js';
+export type Provider = {
+    logger: Logger;
+    isCorrectEnvironment(): boolean;
+    postMessage(message: Uint8Array): void;
+    subscribe(callback: (message: Uint8Array) => void): () => void;
+    dispose(): void;
+};

package/dist/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/transport.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from './provider.js';
+import type { Transport } from './types.js';
+export declare function createTransport(provider: Provider): Transport;