@novasamatech/host-papp 0.8.7 → 0.8.9

package/dist/index.d.ts

@@ -9,6 +9,6 @@ export { AllowanceError } from './sso/allowance/index.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, SigningPayloadResponse, SigningRawRequest, SigningRequest, } from './sso/sessionManager/scale/signing.js';
+export type { SignRawLegacyRequest, SignRawLegacyResponse, SigningPayloadRequest, SigningPayloadResponse, SigningRawRequest, SigningRequest, } from './sso/sessionManager/scale/signing.js';
 export type { RingVrfAliasRequest, RingVrfAliasResponse } from './sso/sessionManager/scale/ringVrf.js';
-export type { CreateTransactionRequest, CreateTransactionResponse, } from './sso/sessionManager/scale/createTransaction.js';
+export type { CreateTransactionLegacyRequest, CreateTransactionRequest, CreateTransactionResponse, } from './sso/sessionManager/scale/createTransaction.js';

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

@@ -16,6 +16,23 @@ export declare const CreateTransactionRequestCodec: import("scale-ts").Codec<{
         };
     };
 }>;
+export type CreateTransactionLegacyRequest = CodecType<typeof CreateTransactionLegacyRequestCodec>;
+export declare const CreateTransactionLegacyRequestCodec: import("scale-ts").Codec<{
+    payload: {
+        tag: "v1";
+        value: {
+            signer: Uint8Array<ArrayBufferLike>;
+            genesisHash: Uint8Array<ArrayBufferLike>;
+            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;

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

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

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

@@ -143,6 +143,42 @@ export declare const RemoteMessageCodec: import("scale-ts").Codec<{
                 respondingTo: string;
                 signedTransaction: import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, string>;
             };
+        } | {
+            tag: "CreateTransactionLegacyRequest";
+            value: {
+                payload: {
+                    tag: "v1";
+                    value: {
+                        signer: Uint8Array<ArrayBufferLike>;
+                        genesisHash: Uint8Array<ArrayBufferLike>;
+                        callData: Uint8Array<ArrayBufferLike>;
+                        extensions: {
+                            id: string;
+                            extra: Uint8Array<ArrayBufferLike>;
+                            additionalSigned: Uint8Array<ArrayBufferLike>;
+                        }[];
+                        txExtVersion: number;
+                    };
+                };
+            };
+        } | {
+            tag: "SignRawLegacyRequest";
+            value: {
+                account: Uint8Array<ArrayBufferLike>;
+                data: {
+                    tag: "Bytes";
+                    value: Uint8Array<ArrayBufferLike>;
+                } | {
+                    tag: "Payload";
+                    value: string;
+                };
+            };
+        } | {
+            tag: "SignRawLegacyResponse";
+            value: {
+                respondingTo: string;
+                signature: 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 { CreateTransactionLegacyRequestCodec, CreateTransactionRequestCodec, CreateTransactionResponseCodec, } from './createTransaction.js';
 import { ResourceAllocationRequestCodec, ResourceAllocationResponseCodec } from './resourceAllocation.js';
 import { RingVrfAliasRequestCodec, RingVrfAliasResponseCodec } from './ringVrf.js';
-import { SigningRequestCodec, SigningResponseCodec } from './signing.js';
+import { SignRawLegacyRequestCodec, SignRawLegacyResponseCodec, SigningRequestCodec, SigningResponseCodec, } from './signing.js';
 export const RemoteMessageCodec = Struct({
     messageId: str,
     data: Enum({
@@ -16,6 +16,9 @@ export const RemoteMessageCodec = Struct({
             ResourceAllocationResponse: ResourceAllocationResponseCodec,
             CreateTransactionRequest: CreateTransactionRequestCodec,
             CreateTransactionResponse: CreateTransactionResponseCodec,
+            CreateTransactionLegacyRequest: CreateTransactionLegacyRequestCodec,
+            SignRawLegacyRequest: SignRawLegacyRequestCodec,
+            SignRawLegacyResponse: SignRawLegacyResponseCodec,
         }),
     }),
 });

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

@@ -29,6 +29,22 @@ export declare const SigningRawRequestCodec: import("scale-ts").Codec<{
         value: string;
     };
 }>;
+export type SignRawLegacyRequest = CodecType<typeof SignRawLegacyRequestCodec>;
+export declare const SignRawLegacyRequestCodec: import("scale-ts").Codec<{
+    account: Uint8Array<ArrayBufferLike>;
+    data: {
+        tag: "Bytes";
+        value: Uint8Array<ArrayBufferLike>;
+    } | {
+        tag: "Payload";
+        value: string;
+    };
+}>;
+export type SignRawLegacyResponse = CodecType<typeof SignRawLegacyResponseCodec>;
+export declare const SignRawLegacyResponseCodec: import("scale-ts").Codec<{
+    respondingTo: string;
+    signature: import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, string>;
+}>;
 export type SigningRequest = CodecType<typeof SigningRequestCodec>;
 export declare const SigningRequestCodec: import("scale-ts").Codec<{
     tag: "Payload";

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

@@ -1,4 +1,4 @@
-import { ProductAccountId } from '@novasamatech/host-api';
+import { AccountId, 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({
@@ -26,6 +26,18 @@ export const SigningRawRequestCodec = Struct({
         Payload: str,
     }),
 });
+export const SignRawLegacyRequestCodec = Struct({
+    account: AccountId,
+    data: Enum({
+        Bytes: Bytes(),
+        Payload: str,
+    }),
+});
+export const SignRawLegacyResponseCodec = Struct({
+    // referencing to RemoteMessage.messageId
+    respondingTo: str,
+    signature: Result(Bytes(), str),
+});
 export const SigningRequestCodec = Enum({
     Payload: SigningPayloadRequestCodec,
     Raw: SigningRawRequestCodec,

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

@@ -5,16 +5,18 @@ 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 type { CreateTransactionLegacyRequest, CreateTransactionRequest } from './scale/createTransaction.js';
 import { RemoteMessageCodec } from './scale/remoteMessage.js';
 import type { ApAllocationOutcome, ResourceAllocationRequest } from './scale/resourceAllocation.js';
-import type { SigningPayloadRequest, SigningPayloadResponseData, SigningRawRequest } from './scale/signing.js';
+import type { SignRawLegacyRequest, SigningPayloadRequest, SigningPayloadResponseData, SigningRawRequest } from './scale/signing.js';
 export type UserSession = StoredUserSession & {
     sendDisconnectMessage(): ResultAsync<void, Error>;
     abortPendingRequests(): ResultAsync<void, Error>;
     signPayload(payload: SigningPayloadRequest): ResultAsync<SigningPayloadResponseData, Error>;
     signRaw(payload: SigningRawRequest): ResultAsync<SigningPayloadResponseData, Error>;
+    signRawLegacy(payload: SignRawLegacyRequest): ResultAsync<Uint8Array, Error>;
     createTransaction(payload: CreateTransactionRequest): ResultAsync<Uint8Array, Error>;
+    createTransactionLegacy(payload: CreateTransactionLegacyRequest): 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

@@ -12,7 +12,7 @@ import { RemoteMessageCodec } from './scale/remoteMessage.js';
 // the remote signer doesn't respond — e.g. the request
 // payload is for an SDK version the mobile app doesn't support yet. After
 // this timeout the queue task fails, freeing the pool for the next request.
-const QUEUE_TASK_TIMEOUT_MS = 180_000;
+const QUEUE_TASK_TIMEOUT_MS = 240_000;
 // Mobile SSO statements allow 500 KiB total; keep headroom for statement/session overhead.
 const MAX_SSO_REQUEST_SIZE = 498 * 1024;
 function withQueueTimeout(resultAsync, label) {
@@ -162,10 +162,61 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 return withHostActionTrace(withQueueTimeout(inner, 'signRaw'), messageId, userSession.id);
             });
         },
+        signRawLegacy(payload) {
+            return enqueue(() => {
+                const messageId = nanoid();
+                const data = enumValue('v1', enumValue('SignRawLegacyRequest', payload));
+                emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
+                const responseFilter = (message) => {
+                    if (message.data.tag === 'v1' &&
+                        message.data.value.tag === 'SignRawLegacyResponse' &&
+                        message.data.value.value.respondingTo === messageId) {
+                        return message.data.value.value.signature;
+                    }
+                };
+                const request = session.request(RemoteMessageCodec, { messageId, data });
+                const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
+                const inner = awaitReplyOrAckFailure(request, reply).andThen(message => {
+                    if (message.success) {
+                        return ok(message.value);
+                    }
+                    else {
+                        return err(new Error(message.value));
+                    }
+                });
+                return withHostActionTrace(withQueueTimeout(inner, 'signRawLegacy'), messageId, userSession.id);
+            });
+        },
         createTransaction(payload) {
             return enqueue(() => {
                 const messageId = nanoid();
                 const data = enumValue('v1', enumValue('CreateTransactionRequest', payload));
+                emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
+                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 request = session.request(RemoteMessageCodec, { messageId, data });
+                const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
+                const inner = awaitReplyOrAckFailure(request, reply).andThen(message => {
+                    if (message.success) {
+                        return ok(message.value);
+                    }
+                    else {
+                        return err(new Error(message.value));
+                    }
+                });
+                return withHostActionTrace(withQueueTimeout(inner, 'createTransaction'), messageId, userSession.id);
+            });
+        },
+        createTransactionLegacy(payload) {
+            return enqueue(() => {
+                const messageId = nanoid();
+                const data = enumValue('v1', enumValue('CreateTransactionLegacyRequest', payload));
+                emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
                 const responseFilter = (message) => {
                     if (message.data.tag === 'v1' &&
                         message.data.value.tag === 'CreateTransactionResponse' &&
@@ -183,7 +234,7 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                         return err(new Error(message.value));
                     }
                 });
-                return withQueueTimeout(inner, 'createTransaction');
+                return withHostActionTrace(withQueueTimeout(inner, 'createTransactionLegacy'), messageId, userSession.id);
             });
         },
         getRingVrfAlias(productAccountId, productId) {
@@ -210,6 +261,7 @@ export function createUserSession({ userSession, statementStore, encryption, sto
             return enqueue(() => {
                 const messageId = nanoid();
                 const data = enumValue('v1', enumValue('ResourceAllocationRequest', payload));
+                emitHostAction(messageId, actionKindFromMessageData(data), userSession.id);
                 const responseFilter = (message) => {
                     if (message.data.tag === 'v1' &&
                         message.data.value.tag === 'ResourceAllocationResponse' &&
@@ -220,7 +272,7 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 const request = session.request(RemoteMessageCodec, { messageId, data });
                 const reply = session.waitForRequestMessage(RemoteMessageCodec, responseFilter);
                 const inner = awaitReplyOrAckFailure(request, reply).andThen(result => result.success ? ok(result.value) : err(new Error(result.value)));
-                return withQueueTimeout(inner, 'requestResourceAllocation');
+                return withHostActionTrace(withQueueTimeout(inner, 'requestResourceAllocation'), messageId, userSession.id);
             });
         },
         sendDisconnectMessage() {
@@ -296,7 +348,7 @@ export function createUserSession({ userSession, statementStore, encryption, sto
         abortPendingRequests() {
             // Drop the whole request queue: aborting the shared signal rejects the
             // in-flight task and every request queued behind it, freeing the single
-            // slot immediately instead of waiting out the per-task 180s timeout. Swap
+            // slot immediately instead of waiting out the per-task timeout. Swap
             // in a fresh controller so subsequent requests aren't pre-aborted.
             requestAbort.abort(new Error('Session request aborted'));
             requestAbort = new AbortController();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -34,10 +34,10 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@novasamatech/host-api": "0.8.7",
-    "@novasamatech/scale": "0.8.7",
-    "@novasamatech/statement-store": "0.8.7",
-    "@novasamatech/storage-adapter": "0.8.7",
+    "@novasamatech/host-api": "0.8.9",
+    "@novasamatech/scale": "0.8.9",
+    "@novasamatech/statement-store": "0.8.9",
+    "@novasamatech/storage-adapter": "0.8.9",
     "@polkadot-api/utils": "^0.4.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.30",
     "nanoevents": "9.1.0",