@novasamatech/host-papp 0.5.4 → 0.6.0

package/dist/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const SS_UNSTABLE_STAGE_ENDPOINTS: string[];
 export declare const SS_STABLE_STAGE_ENDPOINTS: string[];
+export declare const SS_PREVIEW_STAGE_ENDPOINTS: string[];

package/dist/constants.js

@@ -3,3 +3,4 @@ export const SS_STABLE_STAGE_ENDPOINTS = [
     'wss://pop3-testnet.parity-lab.parity.io:443/7911',
     'wss://pop3-testnet.parity-lab.parity.io:443/7912',
 ];
+export const SS_PREVIEW_STAGE_ENDPOINTS = ['wss://previewnet.substrate.dev/people'];

package/dist/crypto.d.ts

@@ -18,7 +18,7 @@ export type DerivedSr25519Account = {
     sign(message: Uint8Array): Uint8Array;
     verify(message: Uint8Array, signature: Uint8Array): boolean;
 };
-export declare function deriveSr25519Account(mnemonic: string, derivation: string): DerivedSr25519Account;
+export declare function deriveSr25519Account(mnemonic: string, derivation?: string): DerivedSr25519Account;
 export declare function createEncrSecret(entropy: Uint8Array): EncrSecret;
 export declare function getEncrPub(secret: EncrSecret): EncrPublicKey;
 export declare function createSharedSecret(secret: EncrSecret, publicKey: Uint8Array): SharedSecret;

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export { SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
+export { SS_PREVIEW_STAGE_ENDPOINTS, SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
 export type { PappAdapter } from './papp.js';
 export { createPappAdapter } from './papp.js';
 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 { SignPayloadRequest } from './sso/sessionManager/scale/signPayloadRequest.js';
-export type { SignPayloadResponse } from './sso/sessionManager/scale/signPayloadResponse.js';
+export type { SignPayloadRequest } from './sso/sessionManager/scale/signingRequest.js';
+export type { SignPayloadResponse } from './sso/sessionManager/scale/signingResponse.js';

package/dist/index.js

@@ -1,2 +1,2 @@
-export { SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
+export { SS_PREVIEW_STAGE_ENDPOINTS, SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
 export { createPappAdapter } from './papp.js';

package/dist/sso/auth/attestationService.d.ts

@@ -2,6 +2,7 @@ import type { LazyClient } from '@novasamatech/statement-store';
 import type { ResultAsync } from 'neverthrow';
 import type { DerivedSr25519Account } from '../../crypto.js';
 export declare function createSudoAliceVerifier(): DerivedSr25519Account;
+export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number): Promise<T>;
 export declare const createAttestationService: (lazyClient: LazyClient) => {
     claimUsername(): string;
     grantVerifierAllowance(verifier: DerivedSr25519Account): ResultAsync<void, Error>;

package/dist/sso/auth/attestationService.js

@@ -6,13 +6,21 @@ import { errAsync, fromAsyncThrowable, fromPromise, okAsync } from 'neverthrow';
 import { AccountId, Binary } from 'polkadot-api';
 import { getPolkadotSigner } from 'polkadot-api/signer';
 import { Bytes, Option, Tuple, str } from 'scale-ts';
-import { member_from_entropy, sign } from 'verifiablejs/bundler';
+import { member_from_entropy, sign } from 'verifiablejs/nodejs';
 import { deriveSr25519Account, getEncrPub, stringToBytes } from '../../crypto.js';
 import { toError } from '../../helpers/utils.js';
 const accountId = AccountId();
 export function createSudoAliceVerifier() {
     return deriveSr25519Account('bottom drive obey lake curtain smoke basket hold race lonely fit walk', '//Alice');
 }
+export function withRetry(fn, maxRetries = 1) {
+    return fn().catch(error => {
+        if (maxRetries > 0) {
+            return withRetry(fn, maxRetries - 1);
+        }
+        throw error;
+    });
+}
 export const createAttestationService = (lazyClient) => {
     const service = {
         claimUsername() {
@@ -35,7 +43,7 @@ export const createAttestationService = (lazyClient) => {
                 const sudoCall = api.tx.Sudo.sudo({
                     call: increaseAllowanceCall.decodedCall,
                 });
-                return sudoCall.signAndSubmit(createPeopleSigner(verifier)).then(() => undefined);
+                return withRetry(() => sudoCall.signAndSubmit(createPeopleSigner(verifier)).then(() => undefined));
             }, toError);
             return verifierAllowance.andThen(verifierAllowance => (verifierAllowance > 0 ? okAsync() : getAllowance()));
         },
@@ -108,7 +116,7 @@ export const createAttestationService = (lazyClient) => {
                         reserved_username: undefined,
                     },
                 });
-                return fromPromise(new Promise((resolve, reject) => {
+                const submitAttestation = () => new Promise((resolve, reject) => {
                     const subscription = attestCall.signSubmitAndWatch(createPeopleSigner(verifier)).subscribe({
                         next(event) {
                             if (event.type === 'finalized') {
@@ -131,7 +139,8 @@ export const createAttestationService = (lazyClient) => {
                         },
                         error: reject,
                     });
-                }), toError).map(() => undefined);
+                });
+                return fromPromise(withRetry(submitAttestation), toError).map(() => undefined);
             })
                 .andTee(() => console.log(`Attestation for ${accountId.dec(candidate.publicKey)} successfully passed.`));
         },

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

@@ -16,7 +16,7 @@ export declare function createSsoSessionManager({ ssoSessionRepository, userSecr
         read: () => UserSession[];
         subscribe: (callback: Callback<UserSession[]>) => () => void;
     };
-    disconnect(userSession: StoredUserSession): import("neverthrow").ResultAsync<undefined, Error>;
+    disconnect(userSession: StoredUserSession): import("neverthrow").ResultAsync<void, Error>;
     dispose(): void;
 };
 export {};

package/dist/sso/sessionManager/impl.js

@@ -49,7 +49,10 @@ export function createSsoSessionManager({ ssoSessionRepository, userSecretReposi
         },
         disconnect(userSession) {
             const session = createSession(userSession, statementStore, storage, userSecretRepository);
-            return session.sendDisconnectMessage().andThen(() => disconnect(userSession));
+            return session
+                .sendDisconnectMessage()
+                .andThen(() => disconnect(userSession))
+                .andThen(() => userSecretRepository.clear(userSession.id));
         },
         dispose() {
             for (const session of Object.values(localSessions.read())) {

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

@@ -10,22 +10,37 @@ export declare const RemoteMessageCodec: import("scale-ts").Codec<{
         } | {
             tag: "SignRequest";
             value: {
-                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;
+                tag: "raw";
+                value: {
+                    address: string;
+                    data: {
+                        tag: "Bytes";
+                        value: Uint8Array<ArrayBufferLike>;
+                    } | {
+                        tag: "Payload";
+                        value: string;
+                    };
+                };
+            } | {
+                tag: "payload";
+                value: {
+                    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;
+                };
             };
         } | {
             tag: "SignResponse";

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

@@ -1,13 +1,13 @@
 import { Enum, Struct, _void, str } from 'scale-ts';
-import { SignPayloadRequestCodec } from './signPayloadRequest.js';
-import { SignPayloadResponseCodec } from './signPayloadResponse.js';
+import { SigningRequestCodec } from './signingRequest.js';
+import { SigningResponseCodec } from './signingResponse.js';
 export const RemoteMessageCodec = Struct({
     messageId: str,
     data: Enum({
         v1: Enum({
             Disconnected: _void,
-            SignRequest: SignPayloadRequestCodec,
-            SignResponse: SignPayloadResponseCodec,
+            SignRequest: SigningRequestCodec,
+            SignResponse: SigningResponseCodec,
         }),
     }),
 });

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

@@ -0,0 +1,64 @@
+import type { CodecType } from 'scale-ts';
+export type SignPayloadRequest = CodecType<typeof SigningPayloadRequestCodec>;
+export declare const SigningPayloadRequestCodec: 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 type SigningRawRequest = CodecType<typeof SigningRawRequestCodec>;
+export declare const SigningRawRequestCodec: import("scale-ts").Codec<{
+    address: string;
+    data: {
+        tag: "Bytes";
+        value: Uint8Array<ArrayBufferLike>;
+    } | {
+        tag: "Payload";
+        value: string;
+    };
+}>;
+export declare const SigningRequestCodec: import("scale-ts").Codec<{
+    tag: "raw";
+    value: {
+        address: string;
+        data: {
+            tag: "Bytes";
+            value: Uint8Array<ArrayBufferLike>;
+        } | {
+            tag: "Payload";
+            value: string;
+        };
+    };
+} | {
+    tag: "payload";
+    value: {
+        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;
+    };
+}>;

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

@@ -0,0 +1,31 @@
+import { Enum, Hex } from '@novasamatech/scale';
+import { Bytes, Option, Struct, Vector, bool, str, u32 } from 'scale-ts';
+export const SigningPayloadRequestCodec = Struct({
+    address: str,
+    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: Option(bool),
+});
+export const SigningRawRequestCodec = Struct({
+    address: str,
+    data: Enum({
+        Bytes: Bytes(),
+        Payload: str,
+    }),
+});
+export const SigningRequestCodec = Enum({
+    payload: SigningPayloadRequestCodec,
+    raw: SigningRawRequestCodec,
+});

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

@@ -0,0 +1,14 @@
+import type { CodecType } from 'scale-ts';
+export type SignPayloadResponseData = CodecType<typeof SignPayloadResponseDataCodec>;
+export declare const SignPayloadResponseDataCodec: import("scale-ts").Codec<{
+    signature: Uint8Array<ArrayBufferLike>;
+    signedTransaction: Uint8Array<ArrayBufferLike> | undefined;
+}>;
+export type SignPayloadResponse = 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/signingResponse.js

@@ -0,0 +1,10 @@
+import { Bytes, Option, Result, Struct, str } from 'scale-ts';
+export const SignPayloadResponseDataCodec = Struct({
+    signature: Bytes(),
+    signedTransaction: Option(Bytes()),
+});
+export const SigningResponseCodec = Struct({
+    // referencing to RemoteMessage.messageId
+    respondingTo: str,
+    payload: Result(SignPayloadResponseDataCodec, str),
+});

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

@@ -5,11 +5,12 @@ import type { CodecType } from 'scale-ts';
 import type { Callback } from '../../types.js';
 import type { StoredUserSession } from '../userSessionRepository.js';
 import { RemoteMessageCodec } from './scale/remoteMessage.js';
-import type { SignPayloadRequest } from './scale/signPayloadRequest.js';
-import type { SignPayloadResponseData } from './scale/signPayloadResponse.js';
+import type { SignPayloadRequest, SigningRawRequest } from './scale/signingRequest.js';
+import type { SignPayloadResponseData } from './scale/signingResponse.js';
 export type UserSession = StoredUserSession & {
     sendDisconnectMessage(): ResultAsync<void, Error>;
     signPayload(payload: SignPayloadRequest): ResultAsync<SignPayloadResponseData, Error>;
+    signRaw(payload: SigningRawRequest): ResultAsync<SignPayloadResponseData, Error>;
     subscribe(callback: Callback<CodecType<typeof RemoteMessageCodec>, ResultAsync<boolean, Error>>): VoidFunction;
     dispose(): void;
 };

package/dist/sso/sessionManager/userSession.js

@@ -32,7 +32,35 @@ export function createUserSession({ userSession, statementStore, encryption, sto
             const messageId = nanoid();
             const request = session.request(RemoteMessageCodec, {
                 messageId,
-                data: enumValue('v1', enumValue('SignRequest', payload)),
+                data: enumValue('v1', enumValue('SignRequest', enumValue('payload', payload))),
+            });
+            const responseFilter = (message) => {
+                if (message.data.tag === 'v1' &&
+                    message.data.value.tag === 'SignResponse' &&
+                    message.data.value.value.respondingTo === messageId) {
+                    return message.data.value.value.payload;
+                }
+            };
+            return request
+                .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
+                .andThen(message => {
+                if (message.success) {
+                    return ok(message.value);
+                }
+                else {
+                    return err(new Error(message.value));
+                }
+            });
+        },
+        signRaw(payload) {
+            const accountId = AccountId();
+            if (toHex(accountId.enc(payload.address)) !== toHex(userSession.remoteAccount.accountId)) {
+                return errAsync(new Error(`Invalid address, got ${payload.address}`));
+            }
+            const messageId = nanoid();
+            const request = session.request(RemoteMessageCodec, {
+                messageId,
+                data: enumValue('v1', enumValue('SignRequest', enumValue('raw', payload))),
             });
             const responseFilter = (message) => {
                 if (message.data.tag === 'v1' &&

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+    "url": "git+https://github.com/Polkadot-Community-Foundation/triangle-js-sdks.git"
   },
   "keywords": [
     "polkadot"
@@ -28,10 +28,10 @@
     "@noble/ciphers": "2.1.1",
     "@noble/curves": "2.0.1",
     "@noble/hashes": "2.0.1",
-    "@novasamatech/host-api": "0.5.4",
-    "@novasamatech/scale": "0.5.4",
-    "@novasamatech/statement-store": "0.5.4",
-    "@novasamatech/storage-adapter": "0.5.4",
+    "@novasamatech/host-api": "0.6.0",
+    "@novasamatech/scale": "0.6.0",
+    "@novasamatech/statement-store": "0.6.0",
+    "@novasamatech/storage-adapter": "0.6.0",
     "@polkadot-api/utils": "0.2.0",
     "@polkadot-api/substrate-bindings": "^0.17.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.27",