@novasamatech/host-papp 0.10.1 → 0.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -38,10 +38,10 @@
     "@noble/ciphers": "2.4.0",
     "@noble/curves": "2.4.0",
     "@noble/hashes": "2.4.0",
-    "@novasamatech/host-api": "0.10.1",
-    "@novasamatech/scale": "0.10.1",
-    "@novasamatech/statement-store": "0.10.1",
-    "@novasamatech/storage-adapter": "0.10.1",
+    "@novasamatech/host-api": "0.11.0",
+    "@novasamatech/scale": "0.11.0",
+    "@novasamatech/statement-store": "0.11.0",
+    "@novasamatech/storage-adapter": "0.11.0",
     "@polkadot-api/utils": "^0.4.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.33",
     "nanoevents": "10.0.0",

package/dist/identity/index.d.ts

@@ -1,2 +0,0 @@
-export type { Credibility, Identity } from './types.js';
-export { createIdentityRpcAdapter } from './rpcAdapter.js';

package/dist/identity/index.js

@@ -1 +0,0 @@
-export { createIdentityRpcAdapter } from './rpcAdapter.js';

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

@@ -1,19 +0,0 @@
-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>;
-    getRingRfKey(candidate: DerivedSr25519Account): Uint8Array<ArrayBufferLike>;
-    getProofMessage(candidate: DerivedSr25519Account, ringVrfKey: Uint8Array): Uint8Array<ArrayBufferLike>;
-    deriveAttestationParams(username: string, candidate: DerivedSr25519Account, verifier: DerivedSr25519Account): ResultAsync<{
-        candidateSignature: Uint8Array<ArrayBufferLike>;
-        ringVrfKey: Uint8Array<ArrayBufferLike>;
-        proofOfOwnership: Uint8Array<ArrayBufferLike>;
-        identifierKey: import("../../crypto.js").EncrPublicKey;
-        consumerRegistrationSignature: Uint8Array<ArrayBufferLike>;
-    }, never>;
-    registerLitePerson(username: string, candidate: DerivedSr25519Account, verifier: DerivedSr25519Account): ResultAsync<void, Error>;
-};

package/dist/sso/auth/attestationService.js

@@ -1,181 +0,0 @@
-import { toHex } from '@novasamatech/scale';
-import { createAccountId } from '@novasamatech/statement-store';
-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 { mergeUint8 } from 'polkadot-api/utils';
-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 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() {
-            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 withRetry(() => 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: toHex(params.candidateSignature),
-                    },
-                    ring_vrf_key: toHex(params.ringVrfKey),
-                    proof_of_ownership: toHex(params.proofOfOwnership),
-                    consumer_registration: {
-                        signature: {
-                            type: 'Sr25519',
-                            value: toHex(params.consumerRegistrationSignature),
-                        },
-                        account: accountId.dec(candidate.publicKey),
-                        identifier_key: toHex(params.identifierKey),
-                        username: Binary.fromText(username),
-                        reserved_username: undefined,
-                    },
-                });
-                const submitAttestation = () => new Promise((resolve, reject) => {
-                    const subscription = attestCall.signSubmitAndWatch(createPeopleSigner(verifier)).subscribe({
-                        next(event) {
-                            if ((event.type === 'txBestBlocksState' && event.found) || event.type === 'finalized') {
-                                subscription.unsubscribe();
-                                if (event.ok) {
-                                    resolve();
-                                }
-                                else {
-                                    let errorMessage = 'Transaction failed';
-                                    if (event.dispatchError?.type === 'Module') {
-                                        const moduleError = event.dispatchError.value;
-                                        errorMessage = `${moduleError.type}.${moduleError.value?.type ?? 'Unknown'}`;
-                                    }
-                                    reject(new Error(errorMessage));
-                                }
-                            }
-                        },
-                        error: reject,
-                        complete: () => reject(new Error('Transaction observable completed without best block confirmation')),
-                    });
-                });
-                return fromPromise(withRetry(submitAttestation), 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) => {
-            // polkadot-api auto-derives all signed extensions whose default state is encodable as
-            // a zero byte (Option::None, struct(Option<_>) = None, etc.). The People runtime's
-            // `pallet_verify_signature::VerifySignature` ({ Disabled, Signed }) extension uses
-            // identifier "VerifyMultiSignature" but has no built-in handler in polkadot-api, so it
-            // must be supplied manually. Value 0x00 = `Disabled` (passthrough — the standard
-            // extrinsic signature authenticates the call). Variant tag order was flipped in
-            // polkadot-sdk#11897 specifically so generic signers can encode the passthrough state
-            // as a single zero byte.
-            const extensionsWithCustom = {
-                ...signedExtensions,
-                VerifyMultiSignature: {
-                    identifier: 'VerifyMultiSignature',
-                    value: new Uint8Array([0]),
-                    additionalSigned: new Uint8Array([]),
-                },
-            };
-            return baseSigner.signTx(callData, extensionsWithCustom, metadata, atBlockNumber, hasher);
-        },
-    };
-}

package/dist/sso/auth/scale/handshake.d.ts

@@ -1,23 +0,0 @@
-export declare const HandshakeData: import("scale-ts").Codec<{
-    tag: "v1";
-    value: {
-        ssPublicKey: import("../../../crypto.js").SsPublicKey;
-        encrPublicKey: import("../../../crypto.js").EncrPublicKey;
-        metadata: string;
-        hostVersion: string | undefined;
-        osType: string | undefined;
-        osVersion: string | undefined;
-    };
-}>;
-export declare const HandshakeResponsePayload: import("scale-ts").Codec<{
-    tag: "v1";
-    value: {
-        encrypted: Uint8Array<ArrayBufferLike>;
-        tmpKey: Uint8Array<ArrayBufferLike>;
-    };
-}>;
-export declare const HandshakeResponseSensitiveData: import("scale-ts").Codec<{
-    sharedSecretDerivationKey: Uint8Array<ArrayBufferLike>;
-    rootUserAccountId: Uint8Array<ArrayBufferLike>;
-    identityAccountId: Uint8Array<ArrayBufferLike>;
-}>;

package/dist/sso/auth/scale/handshake.js

@@ -1,22 +0,0 @@
-import { Enum } from '@novasamatech/scale';
-import { Bytes, Option, Struct, str } from 'scale-ts';
-import { EncrPubKey, SsPubKey } from '../../../crypto.js';
-const optStr = Option(str);
-export const HandshakeData = Enum({
-    v1: Struct({
-        ssPublicKey: SsPubKey,
-        encrPublicKey: EncrPubKey,
-        metadata: str,
-        hostVersion: optStr,
-        osType: optStr,
-        osVersion: optStr,
-    }),
-});
-export const HandshakeResponsePayload = Enum({
-    v1: Struct({ encrypted: Bytes(), tmpKey: Bytes(65) }),
-});
-export const HandshakeResponseSensitiveData = Struct({
-    sharedSecretDerivationKey: Bytes(65),
-    rootUserAccountId: Bytes(32),
-    identityAccountId: Bytes(32),
-});

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

@@ -1,65 +0,0 @@
-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;
-        };
-    };
-}>;

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

@@ -1,32 +0,0 @@
-import { ProductAccountId } from '@novasamatech/host-api';
-import { Enum, Hex, OptionBool } from '@novasamatech/scale';
-import { Bytes, Option, 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,
-});

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

@@ -1,14 +0,0 @@
-import type { CodecType } from 'scale-ts';
-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/signingResponse.js

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