@novasamatech/host-papp 0.5.0-8 → 0.5.0

package/dist/sso/auth/attestationService.js

@@ -0,0 +1,171 @@
+import { createAccountId } from '@novasamatech/statement-store';
+import { mergeUint8 } from '@polkadot-api/utils';
+import { blake2b256 } from '@polkadot-labs/hdkd-helpers';
+import { customAlphabet } from 'nanoid';
+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 { deriveSr25519Account, getEncrPub, stringToBytes } from '../../crypto.js';
+import { toError } from '../../helpers/utils.js';
+const accountId = AccountId();
+export function createAliceVerifier() {
+    return deriveSr25519Account('bottom drive obey lake curtain smoke basket hold race lonely fit walk', '//Alice');
+}
+export const createAttestationService = (lazyClient) => {
+    const service = {
+        claimUsername() {
+            const nameSuffixFactory = customAlphabet('abcdefghijklmnopqrstuvwxyz', 4);
+            return `guest${nameSuffixFactory()}.${createNumericSuffix(4)}`;
+        },
+        grantVerifierAllowance(verifier) {
+            const client = lazyClient.getClient();
+            const api = client.getUnsafeApi();
+            const verifierAddress = accountId.dec(verifier.publicKey);
+            if (!api.query.PeopleLite || !api.query.PeopleLite.AttestationAllowance) {
+                return errAsync(new Error('Query PeopleLite.AttestationAllowance not found.'));
+            }
+            const verifierAllowance = fromPromise(api.query.PeopleLite.AttestationAllowance.getValue(verifierAddress), toError);
+            const getAllowance = fromAsyncThrowable(async () => {
+                const increaseAllowanceCall = api.tx.PeopleLite.increase_attestation_allowance({
+                    account: verifierAddress,
+                    count: 10,
+                });
+                const sudoCall = api.tx.Sudo.sudo({
+                    call: increaseAllowanceCall.decodedCall,
+                });
+                return sudoCall.signAndSubmit(createPeopleSigner(verifier)).then(() => undefined);
+            }, toError);
+            return verifierAllowance.andThen(verifierAllowance => (verifierAllowance > 0 ? okAsync() : getAllowance()));
+        },
+        getRingRfKey(candidate) {
+            const verifiableEntropy = blake2b256(candidate.entropy);
+            return member_from_entropy(verifiableEntropy);
+        },
+        getProofMessage(candidate, ringVrfKey) {
+            return mergeUint8([stringToBytes('pop:people-lite:register using'), candidate.publicKey, ringVrfKey]);
+        },
+        deriveAttestationParams(username, candidate, verifier) {
+            const verifiableEntropy = blake2b256(candidate.entropy);
+            const ringVrfKey = service.getRingRfKey(candidate);
+            const identifierKey = getEncrPub(blake2b256(candidate.secret));
+            const message = service.getProofMessage(candidate, ringVrfKey);
+            // Extract username without the `.` separator and any following digits
+            // For lite person usernames like "ceainnhgidpj.39642086", we only use "ceainnhgidpj"
+            const usernameWithoutDigits = username.split('.')[0] ?? username;
+            const candidateSignature = candidate.sign(message);
+            const proofOfOwnership = sign(verifiableEntropy, message);
+            const ResourceSignatureCodec = Tuple(
+            // candidate PublicKey (32 bytes)
+            Bytes(32), 
+            // verifier AccountId (32 bytes)
+            Bytes(32), 
+            // identifierKey
+            Bytes(65), 
+            // username without digits
+            str, 
+            // reserved_username
+            Option(Bytes()));
+            const resourcesSignatureData = ResourceSignatureCodec.enc([
+                candidate.publicKey,
+                createAccountId(verifier.publicKey),
+                identifierKey,
+                usernameWithoutDigits,
+                undefined,
+            ]);
+            const consumerRegistrationSignature = candidate.sign(resourcesSignatureData);
+            return okAsync({
+                candidateSignature: candidateSignature,
+                ringVrfKey,
+                proofOfOwnership,
+                identifierKey,
+                consumerRegistrationSignature,
+            });
+        },
+        registerLitePerson(username, candidate, verifier) {
+            const client = lazyClient.getClient();
+            const api = client.getUnsafeApi();
+            return service
+                .deriveAttestationParams(username, candidate, verifier)
+                .andThen(params => {
+                const attestCall = api.tx.PeopleLite.attest({
+                    candidate: accountId.dec(candidate.publicKey),
+                    candidate_signature: {
+                        type: 'Sr25519',
+                        value: Binary.fromBytes(params.candidateSignature),
+                    },
+                    ring_vrf_key: Binary.fromBytes(params.ringVrfKey),
+                    proof_of_ownership: Binary.fromBytes(params.proofOfOwnership),
+                    consumer_registration: {
+                        signature: {
+                            type: 'Sr25519',
+                            value: Binary.fromBytes(params.consumerRegistrationSignature),
+                        },
+                        account: accountId.dec(candidate.publicKey),
+                        identifier_key: Binary.fromBytes(params.identifierKey),
+                        username: Binary.fromText(username),
+                        reserved_username: undefined,
+                    },
+                });
+                return fromPromise(new Promise((resolve, reject) => {
+                    const subscription = attestCall.signSubmitAndWatch(createPeopleSigner(verifier)).subscribe({
+                        next(event) {
+                            if (event.type === 'finalized') {
+                                // Check if transaction was successful
+                                if (event.ok) {
+                                    subscription.unsubscribe();
+                                    resolve();
+                                }
+                                else {
+                                    // Extract error details
+                                    let errorMessage = 'Transaction failed';
+                                    if (event.dispatchError?.type === 'Module') {
+                                        const moduleError = event.dispatchError.value;
+                                        errorMessage = `${moduleError.type}.${moduleError.value?.type || 'Unknown'}`;
+                                    }
+                                    subscription.unsubscribe();
+                                    reject(errorMessage);
+                                }
+                            }
+                        },
+                        error: reject,
+                    });
+                }), toError).map(() => undefined);
+            })
+                .andTee(() => console.log(`Attestation for ${accountId.dec(candidate.publicKey)} successfully passed.`));
+        },
+    };
+    return service;
+};
+function createNumericSuffix(length) {
+    let suffix = '';
+    for (let i = 0; i < length; i++) {
+        suffix += (Math.random() * 9).toFixed();
+    }
+    return suffix;
+}
+function createPeopleSigner(verifier) {
+    const baseSigner = getPolkadotSigner(verifier.publicKey, 'Sr25519', verifier.sign);
+    return {
+        publicKey: baseSigner.publicKey,
+        signBytes: baseSigner.signBytes,
+        signTx: async (callData, signedExtensions, metadata, atBlockNumber, hasher) => {
+            // Add People chain custom signed extensions
+            const extensionsWithCustom = {
+                ...signedExtensions,
+                VerifyMultiSignature: {
+                    identifier: 'VerifyMultiSignature',
+                    value: new Uint8Array([1]), // 1u8 = Option::Some with empty data
+                    additionalSigned: new Uint8Array([]), // Empty additional data
+                },
+                AsPerson: {
+                    identifier: 'AsPerson',
+                    value: new Uint8Array([0]), // 0u8 = Option::None
+                    additionalSigned: new Uint8Array([]), // Empty additional data
+                },
+            };
+            return baseSigner.signTx(callData, extensionsWithCustom, metadata, atBlockNumber, hasher);
+        },
+    };
+}

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

@@ -0,0 +1,79 @@
+import type { LazyClient, StatementStoreAdapter } from '@novasamatech/statement-store';
+import { ResultAsync } from 'neverthrow';
+import type { UserSecretRepository } from '../userSecretRepository.js';
+import type { StoredUserSession, UserSessionRepository } from '../userSessionRepository.js';
+export type AuthComponent = ReturnType<typeof createAuth>;
+type Params = {
+    metadata: string;
+    statementStore: StatementStoreAdapter;
+    ssoSessionRepository: UserSessionRepository;
+    userSecretRepository: UserSecretRepository;
+    lazyClient: LazyClient;
+};
+export declare function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient, }: Params): {
+    pairingStatus: {
+        read: () => {
+            step: "none";
+        } | {
+            step: "initial";
+        } | {
+            step: "attestation";
+        } | {
+            step: "pairing";
+            payload: string;
+        } | {
+            step: "pairingError";
+            message: string;
+        } | {
+            step: "finished";
+            session: StoredUserSession;
+        };
+        subscribe: (fn: (value: {
+            step: "none";
+        } | {
+            step: "initial";
+        } | {
+            step: "attestation";
+        } | {
+            step: "pairing";
+            payload: string;
+        } | {
+            step: "pairingError";
+            message: string;
+        } | {
+            step: "finished";
+            session: StoredUserSession;
+        }) => void) => () => void;
+        onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+        onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+    };
+    attestationStatus: {
+        read: () => {
+            step: "none";
+        } | {
+            step: "attestation";
+            username: string;
+        } | {
+            step: "attestationError";
+            message: string;
+        } | {
+            step: "finished";
+        };
+        subscribe: (fn: (value: {
+            step: "none";
+        } | {
+            step: "attestation";
+            username: string;
+        } | {
+            step: "attestationError";
+            message: string;
+        } | {
+            step: "finished";
+        }) => void) => () => void;
+        onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+        onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+    };
+    authenticate(): ResultAsync<StoredUserSession | null, Error>;
+    abortAuthentication(): void;
+};
+export {};

package/dist/sso/auth/impl.js

@@ -0,0 +1,186 @@
+import { createAccountId, createEncryption, createLocalSessionAccount, createRemoteSessionAccount, khash, } from '@novasamatech/statement-store';
+import { mergeUint8, toHex } from '@polkadot-api/utils';
+import { generateMnemonic } from '@polkadot-labs/hdkd-helpers';
+import { Result, ResultAsync, err, fromPromise, fromThrowable, ok } from 'neverthrow';
+import { createEncrSecret, createSharedSecret, deriveSr25519Account, getEncrPub, stringToBytes } from '../../crypto.js';
+import { AbortError } from '../../helpers/abortError.js';
+import { createState, readonly } from '../../helpers/state.js';
+import { toError } from '../../helpers/utils.js';
+import { createStoredUserSession } from '../userSessionRepository.js';
+import { createAliceVerifier, createAttestationService } from './attestationService.js';
+import { HandshakeData, HandshakeResponsePayload, HandshakeResponseSensitiveData } from './scale/handshake.js';
+export function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient, }) {
+    const attestationStatus = createState({ step: 'none' });
+    const pairingStatus = createState({ step: 'none' });
+    let authResult = null;
+    let abort = null;
+    function attestAccount(account, signal) {
+        const attestationService = createAttestationService(lazyClient);
+        const verifier = createAliceVerifier();
+        const username = attestationService.claimUsername();
+        attestationStatus.write({ step: 'attestation', username });
+        return attestationService
+            .grantVerifierAllowance(verifier)
+            .andThrough(() => processSignal(signal))
+            .andThen(() => attestationService.registerLitePerson(username, account, verifier))
+            .andThrough(() => processSignal(signal))
+            .andTee(() => {
+            attestationStatus.write({ step: 'finished' });
+        })
+            .orTee(e => {
+            if (!(e instanceof AbortError)) {
+                attestationStatus.write({ step: 'attestationError', message: e.message });
+            }
+        });
+    }
+    function handshake(account, signal) {
+        const localAccount = createLocalSessionAccount(createAccountId(account.publicKey));
+        pairingStatus.write({ step: 'initial' });
+        const encrKeys = createEncrKeys(account.entropy);
+        const handshakePayload = encrKeys.andThen(({ publicKey }) => createHandshakePayloadV1({
+            ssPublicKey: account.publicKey,
+            encrPublicKey: publicKey,
+            metadata,
+        }));
+        const handshakeTopic = encrKeys.andThen(({ publicKey }) => createHandshakeTopic(localAccount, publicKey));
+        const dataPrepared = Result.combine([handshakePayload, handshakeTopic, encrKeys]).andTee(([payload]) => pairingStatus.write({ step: 'pairing', payload: createDeeplink(payload) }));
+        return dataPrepared.asyncAndThen(([, handshakeTopic, encrKeys]) => {
+            const pappResponse = waitForStatements(callback => statementStore.subscribeStatements([handshakeTopic], callback), signal, (statements, resolve) => {
+                for (const statement of statements) {
+                    if (!statement.data)
+                        continue;
+                    const session = retrieveSession({
+                        localAccount,
+                        encrSecret: encrKeys.secret,
+                        payload: statement.data.asBytes(),
+                    }).unwrapOr(null);
+                    if (session) {
+                        resolve(session);
+                        break;
+                    }
+                }
+            });
+            const secretesSaved = pappResponse.andThen(({ id }) => {
+                return userSecretRepository.write(id, {
+                    ssSecret: account.secret,
+                    encrSecret: encrKeys.secret,
+                    entropy: account.entropy,
+                });
+            });
+            // secrets and sso session should be chained, or it can produce an incorrect state
+            const userCreated = secretesSaved.andThen(() => pappResponse.andThen(ssoSessionRepository.add));
+            const sessionReceived = ResultAsync.combine([userCreated, secretesSaved]).map(([session]) => session);
+            return sessionReceived
+                .andTee(session => {
+                pairingStatus.write(session ? { step: 'finished', session } : { step: 'none' });
+            })
+                .orTee(e => {
+                if (!(e instanceof AbortError)) {
+                    pairingStatus.write({ step: 'pairingError', message: e.message });
+                }
+            });
+        });
+    }
+    const authModule = {
+        pairingStatus: readonly(pairingStatus),
+        attestationStatus: readonly(attestationStatus),
+        authenticate() {
+            if (authResult) {
+                return authResult;
+            }
+            abort = new AbortController();
+            const account = deriveSr25519Account(generateMnemonic(), '//wallet//sso');
+            authResult = ResultAsync.combine([handshake(account, abort.signal), attestAccount(account, abort.signal)])
+                .map(([session]) => session)
+                .orElse(e => (e instanceof AbortError ? ok(null) : err(e)))
+                .andTee(() => {
+                abort = null;
+            })
+                .orTee(() => {
+                authResult = null;
+                abort = null;
+            });
+            return authResult;
+        },
+        abortAuthentication() {
+            if (abort) {
+                abort.abort(new AbortError('Aborted by user.'));
+                abort = null;
+            }
+            authResult = null;
+            pairingStatus.reset();
+            attestationStatus.reset();
+        },
+    };
+    return authModule;
+}
+const createHandshakeTopic = fromThrowable((account, encrPublicKey) => khash(account.accountId, mergeUint8([encrPublicKey, stringToBytes('topic')])), toError);
+const createHandshakePayloadV1 = fromThrowable(({ encrPublicKey, ssPublicKey, metadata, }) => HandshakeData.enc({
+    tag: 'v1',
+    value: [ssPublicKey, encrPublicKey, metadata],
+}), toError);
+function parseHandshakePayload(payload) {
+    const decoded = HandshakeResponsePayload.dec(payload);
+    switch (decoded.tag) {
+        case 'v1':
+            return {
+                encrypted: decoded.value[0],
+                tmpKey: decoded.value[1],
+            };
+        default:
+            throw new Error('Unsupported handshake payload version');
+    }
+}
+const createEncrKeys = fromThrowable((entropy) => {
+    const secret = createEncrSecret(entropy);
+    return {
+        secret,
+        publicKey: getEncrPub(secret),
+    };
+}, toError);
+function retrieveSession({ payload, encrSecret, localAccount, }) {
+    const { encrypted, tmpKey } = parseHandshakePayload(payload);
+    const symmetricKey = createSharedSecret(encrSecret, tmpKey);
+    return createEncryption(symmetricKey)
+        .decrypt(encrypted)
+        .map(decrypted => {
+        const [pappEncrPublicKey, pappAccountId] = HandshakeResponseSensitiveData.dec(decrypted);
+        const sharedSecret = createSharedSecret(encrSecret, pappEncrPublicKey);
+        const peerAccount = createRemoteSessionAccount(createAccountId(pappAccountId), sharedSecret);
+        return createStoredUserSession(localAccount, peerAccount);
+    });
+}
+function createDeeplink(payload) {
+    return `polkadotapp://pair?handshake=${toHex(payload)}`;
+}
+function waitForStatements(subscribe, signal, callback) {
+    return fromPromise(new Promise((resolve, reject) => {
+        const unsubscribe = subscribe(statements => {
+            const abortError = processSignal(signal).match(() => null, e => e);
+            if (abortError) {
+                unsubscribe();
+                reject(abortError);
+                return;
+            }
+            try {
+                callback(statements, value => {
+                    unsubscribe();
+                    resolve(value);
+                });
+            }
+            catch (e) {
+                unsubscribe();
+                reject(e);
+            }
+        });
+    }), toError);
+}
+function processSignal(signal) {
+    try {
+        signal.throwIfAborted();
+        return ok();
+    }
+    catch (e) {
+        return err(toError(e));
+    }
+}

package/dist/{components/auth/codec.d.ts → sso/auth/scale/handshake.d.ts}

@@ -1,9 +1,9 @@
 export declare const HandshakeData: import("scale-ts").Codec<{
-    tag: "V1";
-    value: [import("../../modules/crypto.js").SsPublicKey, import("../../modules/crypto.js").EncrPublicKey, string];
+    tag: "v1";
+    value: [import("../../../crypto.js").SsPublicKey, import("../../../crypto.js").EncrPublicKey, string];
 }>;
 export declare const HandshakeResponsePayload: import("scale-ts").Codec<{
-    tag: "V1";
+    tag: "v1";
     value: [Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>];
 }>;
 export declare const HandshakeResponseSensitiveData: import("scale-ts").Codec<[Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>]>;

package/dist/{components/auth/codec.js → sso/auth/scale/handshake.js}

@@ -1,10 +1,10 @@
 import { Bytes, Enum, Tuple, str } from 'scale-ts';
-import { EncrPubKey, SsPubKey } from '../../modules/crypto.js';
+import { EncrPubKey, SsPubKey } from '../../../crypto.js';
 export const HandshakeData = Enum({
-    V1: Tuple(SsPubKey, EncrPubKey, str),
+    v1: Tuple(SsPubKey, EncrPubKey, str),
 });
 export const HandshakeResponsePayload = Enum({
     // [encrypted, tmp_key]
-    V1: Tuple(Bytes(), Bytes(65)),
+    v1: Tuple(Bytes(), Bytes(65)),
 });
 export const HandshakeResponseSensitiveData = Tuple(Bytes(65), Bytes(32));

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

@@ -0,0 +1,28 @@
+import type { StoredUserSession } from '../userSessionRepository.js';
+export type PairingStatus = {
+    step: 'none';
+} | {
+    step: 'initial';
+} | {
+    step: 'attestation';
+} | {
+    step: 'pairing';
+    payload: string;
+} | {
+    step: 'pairingError';
+    message: string;
+} | {
+    step: 'finished';
+    session: StoredUserSession;
+};
+export type AttestationStatus = {
+    step: 'none';
+} | {
+    step: 'attestation';
+    username: string;
+} | {
+    step: 'attestationError';
+    message: string;
+} | {
+    step: 'finished';
+};

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

@@ -0,0 +1,22 @@
+import type { StatementStoreAdapter } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { Callback } from '../../types.js';
+import type { UserSecretRepository } from '../userSecretRepository.js';
+import type { StoredUserSession, UserSessionRepository } from '../userSessionRepository.js';
+import type { UserSession } from './userSession.js';
+export type SsoSessionManager = ReturnType<typeof createSsoSessionManager>;
+type Params = {
+    storage: StorageAdapter;
+    statementStore: StatementStoreAdapter;
+    ssoSessionRepository: UserSessionRepository;
+    userSecretRepository: UserSecretRepository;
+};
+export declare function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, statementStore, storage, }: Params): {
+    sessions: {
+        read: () => UserSession[];
+        subscribe: (callback: Callback<UserSession[]>) => () => void;
+    };
+    disconnect(userSession: StoredUserSession): import("neverthrow").ResultAsync<undefined, Error>;
+    dispose(): void;
+};
+export {};

package/dist/sso/sessionManager/impl.js

@@ -0,0 +1,71 @@
+import { createEncryption } from '@novasamatech/statement-store';
+import { okAsync } from 'neverthrow';
+import { createState } from '../../helpers/state.js';
+import { createSsoStatementProver } from '../ssoSessionProver.js';
+import { createUserSession } from './userSession.js';
+export function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, statementStore, storage, }) {
+    const localSessions = createState({});
+    const disconnect = (session) => {
+        return ssoSessionRepository.filter(s => s.id !== session.id).map(() => undefined);
+    };
+    ssoSessionRepository.subscribe(userSessions => {
+        const activeSessions = localSessions.read();
+        const toRemove = new Set(Object.keys(activeSessions));
+        const toAdd = new Set();
+        for (const userSession of userSessions) {
+            if (userSession.id in activeSessions)
+                continue;
+            const session = createSession(userSession, statementStore, storage, userSecretRepository);
+            toRemove.delete(userSession.id);
+            toAdd.add(session);
+            session.subscribe(message => {
+                switch (message.data.tag) {
+                    case 'v1': {
+                        switch (message.data.value.tag) {
+                            case 'Disconnected':
+                                return disconnect(userSession).map(() => true);
+                        }
+                    }
+                }
+                return okAsync(false);
+            });
+        }
+        if (toRemove.size > 0) {
+            localSessions.write(prev => {
+                return Object.fromEntries(Object.entries(prev).filter(([id]) => !toRemove.has(id)));
+            });
+        }
+        if (toAdd.size > 0) {
+            localSessions.write(prev => ({
+                ...prev,
+                ...Object.fromEntries(Array.from(toAdd).map(s => [s.id, s])),
+            }));
+        }
+    });
+    return {
+        sessions: {
+            read: () => Object.values(localSessions.read()),
+            subscribe: (callback) => localSessions.subscribe(sessions => callback(Object.values(sessions))),
+        },
+        disconnect(userSession) {
+            const session = createSession(userSession, statementStore, storage, userSecretRepository);
+            return session.sendDisconnectMessage().andThen(() => disconnect(userSession));
+        },
+        dispose() {
+            for (const session of Object.values(localSessions.read())) {
+                session.dispose();
+            }
+        },
+    };
+}
+function createSession(userSession, statementStore, storage, userSecretRepository) {
+    const encryption = createEncryption(userSession.remoteAccount.publicKey);
+    const prover = createSsoStatementProver(userSession, userSecretRepository);
+    return createUserSession({
+        userSession,
+        statementStore,
+        encryption,
+        storage,
+        prover,
+    });
+}

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

@@ -0,0 +1 @@
+export declare const hexCodec: import("scale-ts").Codec<`0x${string}`>;

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

@@ -0,0 +1,3 @@
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { Bytes, enhanceCodec } from 'scale-ts';
+export const hexCodec = enhanceCodec(Bytes(), fromHex, v => toHex(v));

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

@@ -0,0 +1,41 @@
+import type { CodecType } from 'scale-ts';
+export type RemoteMessage = CodecType<typeof RemoteMessageCodec>;
+export declare const RemoteMessageCodec: import("scale-ts").Codec<{
+    messageId: string;
+    data: {
+        tag: "v1";
+        value: {
+            tag: "Disconnected";
+            value: undefined;
+        } | {
+            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: "SignResponse";
+            value: {
+                respondingTo: string;
+                payload: import("scale-ts").ResultPayload<{
+                    signature: Uint8Array<ArrayBufferLike>;
+                    signedTransaction: Uint8Array<ArrayBufferLike> | undefined;
+                }, string>;
+            };
+        };
+    };
+}>;

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

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

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

@@ -0,0 +1,20 @@
+import type { CodecType } from 'scale-ts';
+export type SignPayloadRequest = CodecType<typeof SignPayloadRequestCodec>;
+export declare const SignPayloadRequestCodec: 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;
+}>;