@novasamatech/host-api 0.5.0-18 → 0.5.0-19

package/dist/{interactions → protocol}/v1/createTransaction.d.ts

@@ -3,21 +3,89 @@ import type { HexString } from '../types.js';
  * createTransaction implementation
  * @see https://github.com/polkadot-js/api/issues/6213
  */
-export declare const CreateTransactionErr: import("scale-ts").Codec<{
-    tag: "Rejected";
-    value: undefined;
-} | {
-    tag: "Unknown";
-    value: {
+export declare const CreateTransactionErr: [import("scale-ts").Encoder<(Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-} | {
-    tag: "FailedToDecode";
-    value: undefined;
-} | {
-    tag: "NotSupported";
-    value: string;
-}>;
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "CreateTransactionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "CreateTransactionErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::NotSupported";
+        className: string;
+        payload: string;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "CreateTransactionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "CreateTransactionErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::NotSupported";
+        className: string;
+        payload: string;
+    })>;
+} & {
+    readonly FailedToDecode: import("../commonCodecs.js").ErrCodec<undefined, "CreateTransactionErr::FailedToDecode">;
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "CreateTransactionErr::Rejected">;
+    readonly NotSupported: import("../commonCodecs.js").ErrCodec<string, "CreateTransactionErr::NotSupported">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "CreateTransactionErr::Unknown">;
+};
 export declare const TxPayloadExtensionV1: import("scale-ts").Codec<{
     id: string;
     extra: `0x${string}`;
@@ -64,75 +132,48 @@ export declare const VersionedTxPayload: import("scale-ts").Codec<{
         };
     };
 }>;
-export declare const CreateTransactionV1_request: import("scale-ts").Codec<[[string, number], {
-    tag: "v1";
-    value: {
-        signer: string | null;
-        callData: `0x${string}`;
-        extensions: {
-            id: string;
-            extra: `0x${string}`;
-            additionalSigned: `0x${string}`;
-        }[];
-        txExtVersion: number;
-        context: {
-            metadata: `0x${string}`;
-            tokenSymbol: string;
-            tokenDecimals: number;
-            bestBlockHeight: number;
-        };
-    };
-}]>;
-export declare const CreateTransactionV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, {
-    tag: "Rejected";
-    value: undefined;
-} | {
-    tag: "Unknown";
-    value: {
+export declare const VersionedPublicTxPayload: import("scale-ts").Codec<TxPayloadV1Public>;
+export declare const CreateTransactionV1_request: import("scale-ts").Codec<[[string, number], TxPayloadV1Public]>;
+export declare const CreateTransactionV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, (Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-} | {
-    tag: "FailedToDecode";
-    value: undefined;
-} | {
-    tag: "NotSupported";
-    value: string;
-}>>;
-export declare const CreateTransactionWithNonProductAccountV1_request: import("scale-ts").Codec<[Uint8Array<ArrayBufferLike>, {
-    tag: "v1";
-    value: {
-        signer: string | null;
-        callData: `0x${string}`;
-        extensions: {
-            id: string;
-            extra: `0x${string}`;
-            additionalSigned: `0x${string}`;
-        }[];
-        txExtVersion: number;
-        context: {
-            metadata: `0x${string}`;
-            tokenSymbol: string;
-            tokenDecimals: number;
-            bestBlockHeight: number;
-        };
-    };
-}]>;
-export declare const CreateTransactionWithNonProductAccountV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, {
-    tag: "Rejected";
-    value: undefined;
-} | {
-    tag: "Unknown";
-    value: {
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>>;
+export declare const CreateTransactionWithNonProductAccountV1_request: import("scale-ts").Codec<TxPayloadV1Public>;
+export declare const CreateTransactionWithNonProductAccountV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, (Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-} | {
-    tag: "FailedToDecode";
-    value: undefined;
-} | {
-    tag: "NotSupported";
-    value: string;
-}>>;
-export interface TxPayloadV1Interface {
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>>;
+export interface TxPayloadV1Public {
     /** Payload version. MUST be 1. */
     version: 1;
     /**

package/dist/protocol/v1/createTransaction.js

@@ -0,0 +1,58 @@
+import { Bytes, Result, Struct, Tuple, Vector, _void, enhanceCodec, str, u32, u8 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, Hex, Nullable } from '../commonCodecs.js';
+import { ProductAccountId } from './accounts.js';
+/**
+ * createTransaction implementation
+ * @see https://github.com/polkadot-js/api/issues/6213
+ */
+export const CreateTransactionErr = ErrEnum('CreateTransactionErr', {
+    FailedToDecode: [_void, 'CreateTransaction: failed to decode'],
+    Rejected: [_void, 'CreateTransaction: rejected'],
+    // Unsupported payload version
+    // Failed to infer missing extensions, some extension is unsupported, etc.
+    NotSupported: [str, 'CreateTransaction: not supported'],
+    Unknown: [GenericErr, 'CreateTransaction: unknown error'],
+});
+export const TxPayloadExtensionV1 = Struct({
+    id: str,
+    extra: Hex(),
+    additionalSigned: Hex(),
+});
+export const TxPayloadContextV1 = Struct({
+    metadata: Hex(),
+    tokenSymbol: str,
+    tokenDecimals: u32,
+    bestBlockHeight: u32,
+});
+export const TxPayloadV1 = Struct({
+    signer: Nullable(str),
+    callData: Hex(),
+    extensions: Vector(TxPayloadExtensionV1),
+    txExtVersion: u8,
+    context: TxPayloadContextV1,
+});
+export const VersionedTxPayload = Enum({
+    v1: TxPayloadV1,
+});
+export const VersionedPublicTxPayload = enhanceCodec(VersionedTxPayload, v => {
+    if (v.version !== 1) {
+        throw new Error(`Unsupported transaction version: ${v}`);
+    }
+    return {
+        tag: 'v1',
+        value: v,
+    };
+}, v => {
+    if (v.tag !== 'v1') {
+        throw new Error(`Unsupported transaction version: ${v}`);
+    }
+    return {
+        version: 1,
+        ...v.value,
+    };
+});
+// transaction in the context of a host api account model
+export const CreateTransactionV1_request = Tuple(ProductAccountId, VersionedPublicTxPayload);
+export const CreateTransactionV1_response = Result(Bytes(), CreateTransactionErr);
+export const CreateTransactionWithNonProductAccountV1_request = VersionedPublicTxPayload;
+export const CreateTransactionWithNonProductAccountV1_response = Result(Bytes(), CreateTransactionErr);

package/dist/{interactions → protocol}/v1/feature.d.ts

@@ -1,11 +1,15 @@
 export declare const Feature: import("scale-ts").Codec<{
-    tag: "chain";
+    tag: "Chain";
     value: `0x${string}`;
 }>;
 export declare const FeatureV1_request: import("scale-ts").Codec<{
-    tag: "chain";
+    tag: "Chain";
     value: `0x${string}`;
 }>;
-export declare const FeatureV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<boolean, {
-    reason: string;
+export declare const FeatureV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<boolean, Error & {
+    name: "GenericError";
+    className: string;
+    payload: {
+        reason: string;
+    };
 }>>;

package/dist/protocol/v1/feature.js

@@ -0,0 +1,7 @@
+import { Result, bool } from 'scale-ts';
+import { Enum, GenericError, GenesisHash } from '../commonCodecs.js';
+export const Feature = Enum({
+    Chain: GenesisHash,
+});
+export const FeatureV1_request = Feature;
+export const FeatureV1_response = Result(bool, GenericError);

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

@@ -0,0 +1,85 @@
+export declare const HandshakeErr: [import("scale-ts").Encoder<(Error & {
+    name: "HandshakeErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "HandshakeErr::Timeout";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "HandshakeErr::UnsupportedProtocolVersion";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "HandshakeErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "HandshakeErr::Timeout";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "HandshakeErr::UnsupportedProtocolVersion";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "HandshakeErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "HandshakeErr::Timeout";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "HandshakeErr::UnsupportedProtocolVersion";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "HandshakeErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "HandshakeErr::Timeout";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "HandshakeErr::UnsupportedProtocolVersion";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly Timeout: import("../commonCodecs.js").ErrCodec<undefined, "HandshakeErr::Timeout">;
+    readonly UnsupportedProtocolVersion: import("../commonCodecs.js").ErrCodec<undefined, "HandshakeErr::UnsupportedProtocolVersion">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "HandshakeErr::Unknown">;
+};
+/**
+ * HandshakeV1_request = 1 - JAM codec
+ */
+export declare const HandshakeV1_request: import("scale-ts").Codec<number>;
+export declare const HandshakeV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "HandshakeErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "HandshakeErr::Timeout";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "HandshakeErr::UnsupportedProtocolVersion";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/protocol/v1/handshake.js

@@ -0,0 +1,12 @@
+import { Result, _void, u8 } from 'scale-ts';
+import { ErrEnum, GenericErr } from '../commonCodecs.js';
+export const HandshakeErr = ErrEnum('HandshakeErr', {
+    Timeout: [_void, 'Handshake: timeout'],
+    UnsupportedProtocolVersion: [_void, 'Handshake: unsupported protocol version'],
+    Unknown: [GenericErr, 'Handshake: unknown error'],
+});
+/**
+ * HandshakeV1_request = 1 - JAM codec
+ */
+export const HandshakeV1_request = u8;
+export const HandshakeV1_response = Result(_void, HandshakeErr);

package/dist/{interactions → protocol}/v1/jsonRpc.d.ts

@@ -1,6 +1,10 @@
 export declare const JsonRpcMessageSendV1_request: import("scale-ts").Codec<[`0x${string}`, string]>;
-export declare const JsonRpcMessageSendV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, {
-    reason: string;
+export declare const JsonRpcMessageSendV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, Error & {
+    name: "GenericError";
+    className: string;
+    payload: {
+        reason: string;
+    };
 }>>;
 export declare const JsonRpcMessageSubscribeV1_start: import("scale-ts").Codec<`0x${string}`>;
 export declare const JsonRpcMessageSubscribeV1_receive: import("scale-ts").Codec<string>;

package/dist/{interactions → protocol}/v1/jsonRpc.js

@@ -1,6 +1,6 @@
 import { Result, Tuple, _void, str } from 'scale-ts';
-import { GenericErr, GenesisHash } from '../commonCodecs.js';
+import { GenericError, GenesisHash } from '../commonCodecs.js';
 export const JsonRpcMessageSendV1_request = Tuple(GenesisHash, str);
-export const JsonRpcMessageSendV1_response = Result(_void, GenericErr);
+export const JsonRpcMessageSendV1_response = Result(_void, GenericError);
 export const JsonRpcMessageSubscribeV1_start = GenesisHash;
 export const JsonRpcMessageSubscribeV1_receive = str;

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

@@ -0,0 +1,90 @@
+export declare const PermissionErr: [import("scale-ts").Encoder<(Error & {
+    name: "PermissionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "PermissionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>, import("scale-ts").Decoder<(Error & {
+    name: "PermissionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "PermissionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "PermissionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "PermissionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "PermissionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "PermissionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    })>;
+} & {
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "PermissionErr::Rejected">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "PermissionErr::Unknown">;
+};
+export declare const ChainConnectPermission: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    name: string;
+}>;
+export declare const Permission: import("scale-ts").Codec<{
+    tag: "ChainSubmit";
+    value: `0x${string}`;
+} | {
+    tag: "ChainConnect";
+    value: {
+        genesisHash: `0x${string}`;
+        name: string;
+    };
+} | {
+    tag: "NetworkRequest";
+    value: string[];
+}>;
+export declare const PermissionRequestV1_request: import("scale-ts").Codec<{
+    tag: "ChainSubmit";
+    value: `0x${string}`;
+} | {
+    tag: "ChainConnect";
+    value: {
+        genesisHash: `0x${string}`;
+        name: string;
+    };
+} | {
+    tag: "NetworkRequest";
+    value: string[];
+}>;
+export declare const PermissionRequestV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "PermissionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "PermissionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>>;

package/dist/protocol/v1/permission.js

@@ -0,0 +1,18 @@
+import { Result, Struct, Vector, _void, str } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, GenesisHash } from '../commonCodecs.js';
+export const PermissionErr = ErrEnum('PermissionErr', {
+    Rejected: [_void, 'Permission: rejected'],
+    Unknown: [GenericErr, 'Permission: unknown error'],
+});
+export const ChainConnectPermission = Struct({
+    genesisHash: GenesisHash,
+    name: str,
+});
+export const Permission = Enum({
+    ChainSubmit: GenesisHash,
+    ChainConnect: ChainConnectPermission,
+    NetworkRequest: Vector(str),
+    // TBD
+});
+export const PermissionRequestV1_request = Permission;
+export const PermissionRequestV1_response = Result(_void, PermissionErr);