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

package/dist/interactions/v1/createTransaction.d.ts

@@ -0,0 +1,197 @@
+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: {
+        reason: string;
+    };
+} | {
+    tag: "FailedToDecode";
+    value: undefined;
+} | {
+    tag: "NotSupported";
+    value: string;
+}>;
+export declare const TxPayloadExtensionV1: import("scale-ts").Codec<{
+    id: string;
+    extra: `0x${string}`;
+    additionalSigned: `0x${string}`;
+}>;
+export declare const TxPayloadContextV1: import("scale-ts").Codec<{
+    metadata: `0x${string}`;
+    tokenSymbol: string;
+    tokenDecimals: number;
+    bestBlockHeight: number;
+}>;
+export declare const TxPayloadV1: import("scale-ts").Codec<{
+    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 VersionedTxPayload: import("scale-ts").Codec<{
+    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_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: {
+        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: {
+        reason: string;
+    };
+} | {
+    tag: "FailedToDecode";
+    value: undefined;
+} | {
+    tag: "NotSupported";
+    value: string;
+}>>;
+export interface TxPayloadV1Interface {
+    /** 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;
+    };
+}

package/dist/interactions/v1/createTransaction.js

@@ -0,0 +1,41 @@
+import { Bytes, Enum, Result, Struct, Tuple, Vector, _void, str, u32, u8 } from 'scale-ts';
+import { GenericErr, Hex, Nullable } from '../commonCodecs.js';
+import { AccountId, ProductAccountId } from './accounts.js';
+/**
+ * createTransaction implementation
+ * @see https://github.com/polkadot-js/api/issues/6213
+ */
+export const CreateTransactionErr = Enum({
+    FailedToDecode: _void,
+    Rejected: _void,
+    // Unsupported payload version
+    // Failed to infer missing extensions, some extension is unsupported, etc.
+    NotSupported: str,
+    Unknown: GenericErr,
+});
+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,
+});
+// transaction in context of host api account model
+export const CreateTransactionV1_request = Tuple(ProductAccountId, VersionedTxPayload);
+export const CreateTransactionV1_response = Result(Bytes(), CreateTransactionErr);
+export const CreateTransactionWithNonProductAccountV1_request = Tuple(AccountId, VersionedTxPayload);
+export const CreateTransactionWithNonProductAccountV1_response = Result(Bytes(), CreateTransactionErr);

package/dist/interactions/v1/feature.d.ts

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

package/dist/interactions/v1/feature.js

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

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

@@ -0,0 +1,28 @@
+export declare const HandshakeErr: import("scale-ts").Codec<{
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+} | {
+    tag: "Timeout";
+    value: undefined;
+} | {
+    tag: "UnsupportedProtocolVersion";
+    value: undefined;
+}>;
+/**
+ * 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, {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+} | {
+    tag: "Timeout";
+    value: undefined;
+} | {
+    tag: "UnsupportedProtocolVersion";
+    value: undefined;
+}>>;

package/dist/interactions/v1/handshake.js

@@ -0,0 +1,12 @@
+import { Enum, Result, _void, u8 } from 'scale-ts';
+import { GenericErr } from '../commonCodecs.js';
+export const HandshakeErr = Enum({
+    Timeout: _void,
+    UnsupportedProtocolVersion: _void,
+    Unknown: GenericErr,
+});
+/**
+ * HandshakeV1_request = 1 - JAM codec
+ */
+export const HandshakeV1_request = u8;
+export const HandshakeV1_response = Result(_void, HandshakeErr);

package/dist/interactions/v1/jsonRpc.d.ts

@@ -0,0 +1,6 @@
+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 JsonRpcMessageSubscribeV1_start: import("scale-ts").Codec<`0x${string}`>;
+export declare const JsonRpcMessageSubscribeV1_receive: import("scale-ts").Codec<string>;

package/dist/interactions/v1/jsonRpc.js

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

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

@@ -0,0 +1,48 @@
+export declare const PermissionErr: import("scale-ts").Codec<{
+    tag: "Rejected";
+    value: undefined;
+} | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+}>;
+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, {
+    tag: "Rejected";
+    value: undefined;
+} | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+}>>;

package/dist/interactions/v1/permission.js

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

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

@@ -0,0 +1,92 @@
+export declare const SigningErr: import("scale-ts").Codec<{
+    tag: "Rejected";
+    value: undefined;
+} | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+} | {
+    tag: "FailedToDecode";
+    value: undefined;
+}>;
+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;
+}, {
+    tag: "Rejected";
+    value: undefined;
+} | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+} | {
+    tag: "FailedToDecode";
+    value: 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;
+}, {
+    tag: "Rejected";
+    value: undefined;
+} | {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+} | {
+    tag: "FailedToDecode";
+    value: undefined;
+}>>;

package/dist/interactions/v1/sign.js

@@ -0,0 +1,43 @@
+import { Bytes, Enum, Option, Result, Struct, Vector, _void, bool, str, u32 } from 'scale-ts';
+import { GenericErr, GenesisHash, Hex } from '../commonCodecs.js';
+// common structures
+export const SigningErr = Enum({
+    FailedToDecode: _void,
+    Rejected: _void,
+    Unknown: GenericErr,
+});
+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/interactions/v1/statementStore.d.ts

@@ -0,0 +1,118 @@
+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").Codec<{
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+} | {
+    tag: "UnableToSign";
+    value: undefined;
+} | {
+    tag: "UnknownAccount";
+    value: undefined;
+}>;
+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;
+    };
+}, {
+    tag: "Unknown";
+    value: {
+        reason: string;
+    };
+} | {
+    tag: "UnableToSign";
+    value: undefined;
+} | {
+    tag: "UnknownAccount";
+    value: undefined;
+}>>;

package/dist/interactions/v1/statementStore.js

@@ -0,0 +1,47 @@
+import { Bytes, Enum, Option, Result, Struct, Tuple, Vector, _void, u32, u64 } from 'scale-ts';
+import { 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 = Enum({
+    UnableToSign: _void,
+    UnknownAccount: _void,
+    Unknown: GenericErr,
+});
+export const StatementStoreCreateProofV1_request = Tuple(ProductAccountId, Statement);
+export const StatementStoreCreateProofV1_response = Result(StatementProof, StatementProofErr);