@novasamatech/host-papp 0.7.8-2 → 0.7.9-0

package/dist/index.d.ts

@@ -6,6 +6,5 @@ export type { AttestationStatus, PairingStatus } from './sso/auth/types.js';
 export type { UserSession } from './sso/sessionManager/userSession.js';
 export type { StoredUserSession } from './sso/userSessionRepository.js';
 export type { Identity } from './identity/types.js';
-export type { SigningPayloadRequest, SigningRawRequest, SigningRequest, } from './sso/sessionManager/scale/signingRequest.js';
-export type { SigningPayloadResponse } from './sso/sessionManager/scale/signingResponse.js';
+export type { SigningPayloadRequest, SigningPayloadResponse, SigningRawRequest, SigningRequest, } from './sso/sessionManager/scale/signing.js';
 export type { RingVrfAliasRequest, RingVrfAliasResponse } from './sso/sessionManager/scale/ringVrf.js';

package/dist/sso/sessionManager/scale/createTransaction.d.ts

@@ -0,0 +1,22 @@
+import type { CodecType } from 'scale-ts';
+export type CreateTransactionRequest = CodecType<typeof CreateTransactionRequestCodec>;
+export declare const CreateTransactionRequestCodec: import("scale-ts").Codec<{
+    payload: {
+        tag: "v1";
+        value: {
+            signer: [string, number];
+            callData: Uint8Array<ArrayBufferLike>;
+            extensions: {
+                id: string;
+                extra: Uint8Array<ArrayBufferLike>;
+                additionalSigned: Uint8Array<ArrayBufferLike>;
+            }[];
+            txExtVersion: number;
+        };
+    };
+}>;
+export type CreateTransactionResponse = CodecType<typeof CreateTransactionResponseCodec>;
+export declare const CreateTransactionResponseCodec: import("scale-ts").Codec<{
+    respondingTo: string;
+    signedTransaction: import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, string>;
+}>;

package/dist/sso/sessionManager/scale/createTransaction.js

@@ -0,0 +1,13 @@
+import { ProductAccountTransaction } from '@novasamatech/host-api';
+import { Enum } from '@novasamatech/scale';
+import { Bytes, Result, Struct, str } from 'scale-ts';
+export const CreateTransactionRequestCodec = Struct({
+    payload: Enum({
+        v1: ProductAccountTransaction,
+    }),
+});
+export const CreateTransactionResponseCodec = Struct({
+    // referencing to RemoteMessage.messageId
+    respondingTo: str,
+    signedTransaction: Result(Bytes(), str),
+});

package/dist/sso/sessionManager/scale/remoteMessage.d.ts

@@ -119,6 +119,29 @@ export declare const RemoteMessageCodec: import("scale-ts").Codec<{
                     value: undefined;
                 })[], string>;
             };
+        } | {
+            tag: "CreateTransactionRequest";
+            value: {
+                payload: {
+                    tag: "v1";
+                    value: {
+                        signer: [string, number];
+                        callData: Uint8Array<ArrayBufferLike>;
+                        extensions: {
+                            id: string;
+                            extra: Uint8Array<ArrayBufferLike>;
+                            additionalSigned: Uint8Array<ArrayBufferLike>;
+                        }[];
+                        txExtVersion: number;
+                    };
+                };
+            };
+        } | {
+            tag: "CreateTransactionResponse";
+            value: {
+                respondingTo: string;
+                signedTransaction: import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, string>;
+            };
         };
     };
 }>;

package/dist/sso/sessionManager/scale/remoteMessage.js

@@ -1,8 +1,8 @@
 import { Enum, Struct, _void, str } from 'scale-ts';
+import { CreateTransactionRequestCodec, CreateTransactionResponseCodec } from './createTransaction.js';
 import { ResourceAllocationRequestCodec, ResourceAllocationResponseCodec } from './resourceAllocation.js';
 import { RingVrfAliasRequestCodec, RingVrfAliasResponseCodec } from './ringVrf.js';
-import { SigningRequestCodec } from './signingRequest.js';
-import { SigningResponseCodec } from './signingResponse.js';
+import { SigningRequestCodec, SigningResponseCodec } from './signing.js';
 export const RemoteMessageCodec = Struct({
     messageId: str,
     data: Enum({
@@ -14,6 +14,8 @@ export const RemoteMessageCodec = Struct({
             RingVrfAliasResponse: RingVrfAliasResponseCodec,
             ResourceAllocationRequest: ResourceAllocationRequestCodec,
             ResourceAllocationResponse: ResourceAllocationResponseCodec,
+            CreateTransactionRequest: CreateTransactionRequestCodec,
+            CreateTransactionResponse: CreateTransactionResponseCodec,
         }),
     }),
 });

package/dist/sso/sessionManager/scale/signing.d.ts

@@ -0,0 +1,78 @@
+import type { CodecType } from 'scale-ts';
+export type SigningPayloadRequest = CodecType<typeof SigningPayloadRequestCodec>;
+export declare const SigningPayloadRequestCodec: import("scale-ts").Codec<{
+    productAccountId: [string, number];
+    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 | void;
+}>;
+export type SigningRawRequest = CodecType<typeof SigningRawRequestCodec>;
+export declare const SigningRawRequestCodec: import("scale-ts").Codec<{
+    productAccountId: [string, number];
+    data: {
+        tag: "Bytes";
+        value: Uint8Array<ArrayBufferLike>;
+    } | {
+        tag: "Payload";
+        value: string;
+    };
+}>;
+export type SigningRequest = CodecType<typeof SigningRequestCodec>;
+export declare const SigningRequestCodec: import("scale-ts").Codec<{
+    tag: "Payload";
+    value: {
+        productAccountId: [string, number];
+        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 | void;
+    };
+} | {
+    tag: "Raw";
+    value: {
+        productAccountId: [string, number];
+        data: {
+            tag: "Bytes";
+            value: Uint8Array<ArrayBufferLike>;
+        } | {
+            tag: "Payload";
+            value: string;
+        };
+    };
+}>;
+export type SigningPayloadResponseData = CodecType<typeof SigningPayloadResponseDataCodec>;
+export declare const SigningPayloadResponseDataCodec: import("scale-ts").Codec<{
+    signature: Uint8Array<ArrayBufferLike>;
+    signedTransaction: Uint8Array<ArrayBufferLike> | undefined;
+}>;
+export type SigningPayloadResponse = CodecType<typeof SigningResponseCodec>;
+export declare const SigningResponseCodec: import("scale-ts").Codec<{
+    respondingTo: string;
+    payload: import("scale-ts").ResultPayload<{
+        signature: Uint8Array<ArrayBufferLike>;
+        signedTransaction: Uint8Array<ArrayBufferLike> | undefined;
+    }, string>;
+}>;

package/dist/sso/sessionManager/scale/signing.js

@@ -0,0 +1,41 @@
+import { ProductAccountId } from '@novasamatech/host-api';
+import { Enum, Hex, OptionBool } from '@novasamatech/scale';
+import { Bytes, Option, Result, Struct, Vector, str, u32 } from 'scale-ts';
+export const SigningPayloadRequestCodec = Struct({
+    productAccountId: ProductAccountId,
+    blockHash: Hex(),
+    blockNumber: Hex(),
+    era: Hex(),
+    genesisHash: Hex(),
+    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: OptionBool,
+});
+export const SigningRawRequestCodec = Struct({
+    productAccountId: ProductAccountId,
+    data: Enum({
+        Bytes: Bytes(),
+        Payload: str,
+    }),
+});
+export const SigningRequestCodec = Enum({
+    Payload: SigningPayloadRequestCodec,
+    Raw: SigningRawRequestCodec,
+});
+export const SigningPayloadResponseDataCodec = Struct({
+    signature: Bytes(),
+    signedTransaction: Option(Bytes()),
+});
+export const SigningResponseCodec = Struct({
+    // referencing to RemoteMessage.messageId
+    respondingTo: str,
+    payload: Result(SigningPayloadResponseDataCodec, str),
+});

package/dist/sso/sessionManager/userSession.d.ts

@@ -5,14 +5,15 @@ import { ResultAsync } from 'neverthrow';
 import type { CodecType } from 'scale-ts';
 import type { Callback } from '../../types.js';
 import type { StoredUserSession } from '../userSessionRepository.js';
+import type { CreateTransactionRequest } from './scale/createTransaction.js';
 import { RemoteMessageCodec } from './scale/remoteMessage.js';
 import type { ApAllocationOutcome, ResourceAllocationRequest } from './scale/resourceAllocation.js';
-import type { SigningPayloadRequest, SigningRawRequest } from './scale/signingRequest.js';
-import type { SigningPayloadResponseData } from './scale/signingResponse.js';
+import type { SigningPayloadRequest, SigningPayloadResponseData, SigningRawRequest } from './scale/signing.js';
 export type UserSession = StoredUserSession & {
     sendDisconnectMessage(): ResultAsync<void, Error>;
     signPayload(payload: SigningPayloadRequest): ResultAsync<SigningPayloadResponseData, Error>;
     signRaw(payload: SigningRawRequest): ResultAsync<SigningPayloadResponseData, Error>;
+    createTransaction(payload: CreateTransactionRequest): ResultAsync<Uint8Array, Error>;
     getRingVrfAlias(productAccountId: CodecType<typeof ProductAccountId>, productId: string): ResultAsync<CodecType<typeof ContextualAlias>, Error>;
     requestResourceAllocation(request: ResourceAllocationRequest): ResultAsync<ApAllocationOutcome[], Error>;
     subscribe(callback: Callback<CodecType<typeof RemoteMessageCodec>, ResultAsync<boolean, Error>>): VoidFunction;

package/dist/sso/sessionManager/userSession.js

@@ -90,6 +90,33 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 return withQueueTimeout(inner, 'signRaw');
             });
         },
+        createTransaction(payload) {
+            return requestQueue.call(() => {
+                const messageId = nanoid();
+                const request = session.request(RemoteMessageCodec, {
+                    messageId,
+                    data: enumValue('v1', enumValue('CreateTransactionRequest', payload)),
+                });
+                const responseFilter = (message) => {
+                    if (message.data.tag === 'v1' &&
+                        message.data.value.tag === 'CreateTransactionResponse' &&
+                        message.data.value.value.respondingTo === messageId) {
+                        return message.data.value.value.signedTransaction;
+                    }
+                };
+                const inner = request
+                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
+                    .andThen(message => {
+                    if (message.success) {
+                        return ok(message.value);
+                    }
+                    else {
+                        return err(new Error(message.value));
+                    }
+                });
+                return withQueueTimeout(inner, 'createTransaction');
+            });
+        },
         sendDisconnectMessage() {
             return requestQueue.call(() => session
                 .submitRequestMessage(RemoteMessageCodec, {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.7.8-2",
+  "version": "0.7.9-0",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -29,10 +29,10 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@novasamatech/host-api": "0.7.8-2",
-    "@novasamatech/scale": "0.7.8-2",
-    "@novasamatech/statement-store": "0.7.8-2",
-    "@novasamatech/storage-adapter": "0.7.8-2",
+    "@novasamatech/host-api": "0.7.9-0",
+    "@novasamatech/scale": "0.7.9-0",
+    "@novasamatech/statement-store": "0.7.9-0",
+    "@novasamatech/storage-adapter": "0.7.9-0",
     "@polkadot-labs/hdkd-helpers": "^0.0.30",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.9",