@bsv/wallet-toolbox 1.7.16 → 1.7.18

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/Peer.d.ts

@@ -1,200 +0,0 @@
-import { SessionManager } from './SessionManager.js';
-import { PeerSession, RequestedCertificateSet, Transport } from './types.js';
-import { VerifiableCertificate } from './certificates/VerifiableCertificate.js';
-import { OriginatorDomainNameStringUnder250Bytes, WalletInterface } from '../wallet/Wallet.interfaces.js';
-/**
- * Represents a peer capable of performing mutual authentication.
- * Manages sessions, handles authentication handshakes, certificate requests and responses,
- * and sending and receiving general messages over a transport layer.
- *
- * This version supports multiple concurrent sessions per peer identityKey.
- */
-export declare class Peer {
-    sessionManager: SessionManager;
-    private readonly transport;
-    private readonly wallet;
-    certificatesToRequest: RequestedCertificateSet;
-    private readonly onGeneralMessageReceivedCallbacks;
-    private readonly onCertificatesReceivedCallbacks;
-    private readonly onCertificateRequestReceivedCallbacks;
-    private readonly onInitialResponseReceivedCallbacks;
-    private callbackIdCounter;
-    private readonly autoPersistLastSession;
-    private lastInteractedWithPeer;
-    private readonly originator?;
-    private identityPublicKey?;
-    /**
-     * Creates a new Peer instance
-     *
-     * @param {WalletInterface} wallet - The wallet instance used for cryptographic operations.
-     * @param {Transport} transport - The transport mechanism used for sending and receiving messages.
-     * @param {RequestedCertificateSet} [certificatesToRequest] - Optional set of certificates to request from a peer during the initial handshake.
-     * @param {SessionManager} [sessionManager] - Optional SessionManager to be used for managing peer sessions.
-     * @param {boolean} [autoPersistLastSession] - Whether to auto-persist the session with the last-interacted-with peer. Defaults to true.
-     */
-    constructor(wallet: WalletInterface, transport: Transport, certificatesToRequest?: RequestedCertificateSet, sessionManager?: SessionManager, autoPersistLastSession?: boolean, originator?: OriginatorDomainNameStringUnder250Bytes);
-    /**
-     * Sends a general message to a peer, and initiates a handshake if necessary.
-     *
-     * @param {number[]} message - The message payload to send.
-     * @param {string} [identityKey] - The identity public key of the peer. If not provided, uses lastInteractedWithPeer (if any).
-     * @param {number} [maxWaitTime] - optional max wait time in ms
-     * @returns {Promise<void>}
-     * @throws Will throw an error if the message fails to send.
-     */
-    toPeer(message: number[], identityKey?: string, maxWaitTime?: number): Promise<void>;
-    /**
-     * Sends a request for certificates to a peer.
-     * This method allows a peer to dynamically request specific certificates after
-     * an initial handshake or message has been exchanged.
-     *
-     * @param {RequestedCertificateSet} certificatesToRequest - Specifies the certifiers and types of certificates required from the peer.
-     * @param {string} [identityKey] - The identity public key of the peer. If not provided, the current or last session identity is used.
-     * @param {number} [maxWaitTime=10000] - Maximum time in milliseconds to wait for the peer session to be authenticated.
-     * @returns {Promise<void>} Resolves if the certificate request message is successfully sent.
-     * @throws Will throw an error if the peer session is not authenticated or if sending the request fails.
-     */
-    requestCertificates(certificatesToRequest: RequestedCertificateSet, identityKey?: string, maxWaitTime?: number): Promise<void>;
-    /**
-     * Retrieves an authenticated session for a given peer identity. If no session exists
-     * or the session is not authenticated, initiates a handshake to create or authenticate the session.
-     *
-     * - If `identityKey` is provided, we look up any existing session for that identity key.
-     * - If none is found or not authenticated, we do a new handshake.
-     * - If `identityKey` is not provided, but we have a `lastInteractedWithPeer`, we try that key.
-     *
-     * @param {string} [identityKey] - The identity public key of the peer.
-     * @param {number} [maxWaitTime] - The maximum time in milliseconds to wait for the handshake.
-     * @returns {Promise<PeerSession>} - A promise that resolves with an authenticated `PeerSession`.
-     */
-    getAuthenticatedSession(identityKey?: string, maxWaitTime?: number): Promise<PeerSession>;
-    /**
-     * Registers a callback to listen for general messages from peers.
-     *
-     * @param {(senderPublicKey: string, payload: number[]) => void} callback - The function to call when a general message is received.
-     * @returns {number} The ID of the callback listener.
-     */
-    listenForGeneralMessages(callback: (senderPublicKey: string, payload: number[]) => void): number;
-    /**
-     * Removes a general message listener.
-     *
-     * @param {number} callbackID - The ID of the callback to remove.
-     */
-    stopListeningForGeneralMessages(callbackID: number): void;
-    /**
-     * Registers a callback to listen for certificates received from peers.
-     *
-     * @param {(senderPublicKey: string, certs: VerifiableCertificate[]) => void} callback - The function to call when certificates are received.
-     * @returns {number} The ID of the callback listener.
-     */
-    listenForCertificatesReceived(callback: (senderPublicKey: string, certs: VerifiableCertificate[]) => void): number;
-    /**
-     * Cancels and unsubscribes a certificatesReceived listener.
-     *
-     * @param {number} callbackID - The ID of the certificates received callback to cancel.
-     */
-    stopListeningForCertificatesReceived(callbackID: number): void;
-    /**
-     * Registers a callback to listen for certificates requested from peers.
-     *
-     * @param {(requestedCertificates: RequestedCertificateSet) => void} callback - The function to call when a certificate request is received
-     * @returns {number} The ID of the callback listener.
-     */
-    listenForCertificatesRequested(callback: (senderPublicKey: string, requestedCertificates: RequestedCertificateSet) => void): number;
-    /**
-     * Cancels and unsubscribes a certificatesRequested listener.
-     *
-     * @param {number} callbackID - The ID of the requested certificates callback to cancel.
-     */
-    stopListeningForCertificatesRequested(callbackID: number): void;
-    /**
-     * Initiates the mutual authentication handshake with a peer.
-     *
-     * @private
-     * @param {string} [identityKey] - The identity public key of the peer.
-     * @param {number} [maxWaitTime=10000] - how long to wait for handshake
-     * @returns {Promise<string>} A promise that resolves to the session nonce.
-     */
-    private initiateHandshake;
-    /**
-     * Waits for the initial response from the peer after sending an initial handshake request message.
-     *
-     * @param {string} sessionNonce - The session nonce created in the initial request.
-     * @returns {Promise<string>} A promise that resolves with the session nonce when the initial response is received.
-     */
-    private waitForInitialResponse;
-    /**
-     * Adds a listener for an initial response message matching a specific initial nonce.
-     *
-     * @private
-     * @param {string} sessionNonce - The session nonce to match.
-     * @param {(sessionNonce: string) => void} callback - The callback to invoke when the initial response is received.
-     * @returns {number} The ID of the callback listener.
-     */
-    private listenForInitialResponse;
-    /**
-     * Removes a listener for initial responses.
-     *
-     * @private
-     * @param {number} callbackID - The ID of the callback to remove.
-     */
-    private stopListeningForInitialResponses;
-    private propagateTransportError;
-    /**
-     * Handles incoming messages from the transport.
-     *
-     * @param {AuthMessage} message - The incoming message to process.
-     * @returns {Promise<void>}
-     */
-    private handleIncomingMessage;
-    /**
-     * Processes an initial request message from a peer.
-     *
-     * @param {AuthMessage} message - The incoming initial request message.
-     */
-    private processInitialRequest;
-    /**
-     * Processes an initial response message from a peer.
-     *
-     * @private
-     * @param {AuthMessage} message - The incoming initial response message.
-     * @throws Will throw an error if nonce or signature verification fails.
-     */
-    private processInitialResponse;
-    /**
-     * Processes an incoming certificate request message from a peer.
-     * Verifies nonce/signature and then possibly sends a certificateResponse.
-     *
-     * @param {AuthMessage} message - The certificate request message received from the peer.
-     * @throws {Error} if nonce or signature is invalid.
-     */
-    private processCertificateRequest;
-    /**
-     * Sends a certificate response message containing the specified certificates to a peer.
-     *
-     * @param {string} verifierIdentityKey - The identity key of the peer requesting the certificates.
-     * @param {VerifiableCertificate[]} certificates - The list of certificates to include in the response.
-     * @throws Will throw an error if the transport fails to send the message.
-     */
-    sendCertificateResponse(verifierIdentityKey: string, certificates: VerifiableCertificate[]): Promise<void>;
-    /**
-     * Processes a certificate response message from a peer.
-     *
-     * @private
-     * @param {AuthMessage} message - The incoming certificate response message.
-     * @throws Will throw an error if nonce verification or signature verification fails.
-     */
-    private processCertificateResponse;
-    /**
-     * Processes a general message from a peer.
-     *
-     * @private
-     * @param {AuthMessage} message - The incoming general message.
-     * @throws Will throw an error if nonce or signature verification fails.
-     */
-    private processGeneralMessage;
-    private getIdentityPublicKey;
-    private static utf8ToBytes;
-    private static base64ToBytes;
-}
-//# sourceMappingURL=Peer.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/Peer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Peer.d.ts","sourceRoot":"","sources":["../../../../src/auth/Peer.ts"],"names":[],"mappings":"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"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/SessionManager.d.ts

@@ -1,60 +0,0 @@
-import { PeerSession } from './types.js';
-/**
- * Manages sessions for peers, allowing multiple concurrent sessions
- * per identity key. Primary lookup is always by `sessionNonce`.
- */
-export declare class SessionManager {
-    /**
-     * Maps sessionNonce -> PeerSession
-     */
-    private readonly sessionNonceToSession;
-    /**
-     * Maps identityKey -> Set of sessionNonces
-     */
-    private readonly identityKeyToNonces;
-    constructor();
-    /**
-     * Adds a session to the manager, associating it with its sessionNonce,
-     * and also with its peerIdentityKey (if any).
-     *
-     * This does NOT overwrite existing sessions for the same peerIdentityKey,
-     * allowing multiple concurrent sessions for the same peer.
-     *
-     * @param {PeerSession} session - The peer session to add.
-     */
-    addSession(session: PeerSession): void;
-    /**
-     * Updates a session in the manager (primarily by re-adding it),
-     * ensuring we record the latest data (e.g., isAuthenticated, lastUpdate, etc.).
-     *
-     * @param {PeerSession} session - The peer session to update.
-     */
-    updateSession(session: PeerSession): void;
-    /**
-     * Retrieves a session based on a given identifier, which can be:
-     *  - A sessionNonce, or
-     *  - A peerIdentityKey.
-     *
-     * If it is a `sessionNonce`, returns that exact session.
-     * If it is a `peerIdentityKey`, returns the "best" (e.g. most recently updated,
-     * authenticated) session associated with that peer, if any.
-     *
-     * @param {string} identifier - The identifier for the session (sessionNonce or peerIdentityKey).
-     * @returns {PeerSession | undefined} - The matching peer session, or undefined if not found.
-     */
-    getSession(identifier: string): PeerSession | undefined;
-    /**
-     * Removes a session from the manager by clearing all associated identifiers.
-     *
-     * @param {PeerSession} session - The peer session to remove.
-     */
-    removeSession(session: PeerSession): void;
-    /**
-     * Checks if a session exists for a given identifier (either sessionNonce or identityKey).
-     *
-     * @param {string} identifier - The identifier to check.
-     * @returns {boolean} - True if the session exists, false otherwise.
-     */
-    hasSession(identifier: string): boolean;
-}
-//# sourceMappingURL=SessionManager.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/SessionManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SessionManager.d.ts","sourceRoot":"","sources":["../../../../src/auth/SessionManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAExC;;;GAGG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAA0B;IAEhE;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA0B;;IAO9D;;;;;;;;OAQG;IACH,UAAU,CAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAqBvC;;;;;OAKG;IACH,aAAa,CAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAM1C;;;;;;;;;;;OAWG;IACH,UAAU,CAAE,UAAU,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAmCxD;;;;OAIG;IACH,aAAa,CAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAe1C;;;;;OAKG;IACH,UAAU,CAAE,UAAU,EAAE,MAAM,GAAG,OAAO;CAOzC"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/Certificate.d.ts

@@ -1,112 +0,0 @@
-import { Base64String, PubKeyHex, HexString, OutpointString, CertificateFieldNameUnder50Bytes, WalletProtocol } from '../../wallet/Wallet.interfaces.js';
-import ProtoWallet from '../../wallet/ProtoWallet.js';
-/**
- * Represents an Identity Certificate as per the Wallet interface specifications.
- *
- * This class provides methods to serialize and deserialize certificates, as well as signing and verifying the certificate's signature.
- */
-export default class Certificate {
-    /**
-     * Type identifier for the certificate, base64 encoded string, 32 bytes.
-     */
-    type: Base64String;
-    /**
-     * Unique serial number of the certificate, base64 encoded string, 32 bytes.
-     */
-    serialNumber: Base64String;
-    /**
-     * The public key belonging to the certificate's subject, compressed public key hex string.
-     */
-    subject: PubKeyHex;
-    /**
-     * Public key of the certifier who issued the certificate, compressed public key hex string.
-     */
-    certifier: PubKeyHex;
-    /**
-     * The outpoint used to confirm that the certificate has not been revoked (TXID.OutputIndex), as a string.
-     */
-    revocationOutpoint: OutpointString;
-    /**
-     * All the fields present in the certificate, with field names as keys and encrypted field values as Base64 strings.
-     */
-    fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-    /**
-     * Certificate signature by the certifier's private key, DER encoded hex string.
-     */
-    signature?: HexString;
-    /**
-     * Constructs a new Certificate.
-     *
-     * @param {Base64String} type - Type identifier for the certificate, base64 encoded string, 32 bytes.
-     * @param {Base64String} serialNumber - Unique serial number of the certificate, base64 encoded string, 32 bytes.
-     * @param {PubKeyHex} subject - The public key belonging to the certificate's subject, compressed public key hex string.
-     * @param {PubKeyHex} certifier - Public key of the certifier who issued the certificate, compressed public key hex string.
-     * @param {OutpointString} revocationOutpoint - The outpoint used to confirm that the certificate has not been revoked (TXID.OutputIndex), as a string.
-     * @param {Record<CertificateFieldNameUnder50Bytes, string>} fields - All the fields present in the certificate.
-     * @param {HexString} signature - Certificate signature by the certifier's private key, DER encoded hex string.
-     */
-    constructor(type: Base64String, serialNumber: Base64String, subject: PubKeyHex, certifier: PubKeyHex, revocationOutpoint: OutpointString, fields: Record<CertificateFieldNameUnder50Bytes, string>, signature?: HexString);
-    /**
-     * Serializes the certificate into binary format, with or without a signature.
-     *
-     * @param {boolean} [includeSignature=true] - Whether to include the signature in the serialization.
-     * @returns {number[]} - The serialized certificate in binary format.
-     */
-    toBinary(includeSignature?: boolean): number[];
-    /**
-     * Deserializes a certificate from binary format.
-     *
-     * @param {number[]} bin - The binary data representing the certificate.
-     * @returns {Certificate} - The deserialized Certificate object.
-     */
-    static fromBinary(bin: number[]): Certificate;
-    /**
-     * Verifies the certificate's signature.
-     *
-     * @returns {Promise<boolean>} - A promise that resolves to true if the signature is valid.
-     */
-    verify(): Promise<boolean>;
-    /**
-   * Signs the certificate using the provided certifier wallet.
-   *
-   * @param {Wallet} certifierWallet - The wallet representing the certifier.
-   * @returns {Promise<void>}
-   */
-    sign(certifierWallet: ProtoWallet): Promise<void>;
-    /**
-     * Helper function which retrieves the protocol ID and key ID for certificate field encryption.
-     *
-     * For master certificate creation, no serial number is provided because entropy is required
-     * from both the client and the certifier. In this case, the `keyID` is simply the `fieldName`.
-     *
-     * For VerifiableCertificates verifier keyring creation, both the serial number and field name are available,
-     * so the `keyID` is formed by concatenating the `serialNumber` and `fieldName`.
-     *
-     * @param fieldName - The name of the field within the certificate to be encrypted.
-     * @param serialNumber - (Optional) The serial number of the certificate.
-     * @returns An object containing:
-     *   - `protocolID` (WalletProtocol): The protocol ID for certificate field encryption.
-     *   - `keyID` (string): A unique key identifier. It is the `fieldName` if `serialNumber` is undefined,
-     *     otherwise it is a combination of `serialNumber` and `fieldName`.
-     */
-    static getCertificateFieldEncryptionDetails(fieldName: string, serialNumber?: string): {
-        protocolID: WalletProtocol;
-        keyID: string;
-    };
-    /**
-     * Creates a Certificate instance from a plain object representation.
-     *
-     * @param obj - The object containing certificate data.
-     * @returns A new Certificate instance.
-     */
-    static fromObject(obj: {
-        type: Base64String;
-        serialNumber: Base64String;
-        subject: PubKeyHex;
-        certifier: PubKeyHex;
-        revocationOutpoint: OutpointString;
-        fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-        signature?: HexString;
-    }): Certificate;
-}
-//# sourceMappingURL=Certificate.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/Certificate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Certificate.d.ts","sourceRoot":"","sources":["../../../../../src/auth/certificates/Certificate.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,SAAS,EACT,SAAS,EACT,cAAc,EACd,gCAAgC,EAChC,cAAc,EACf,MAAM,mCAAmC,CAAA;AAE1C,OAAO,WAAW,MAAM,6BAA6B,CAAA;AAGrD;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,WAAW;IAC9B;;OAEG;IACH,IAAI,EAAE,YAAY,CAAA;IAElB;;OAEG;IACH,YAAY,EAAE,YAAY,CAAA;IAE1B;;OAEG;IACH,OAAO,EAAE,SAAS,CAAA;IAElB;;OAEG;IACH,SAAS,EAAE,SAAS,CAAA;IAEpB;;OAEG;IACH,kBAAkB,EAAE,cAAc,CAAA;IAElC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,gCAAgC,EAAE,YAAY,CAAC,CAAA;IAE9D;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IAErB;;;;;;;;;;OAUG;gBAED,IAAI,EAAE,YAAY,EAClB,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,SAAS,EAAE,SAAS,EACpB,kBAAkB,EAAE,cAAc,EAClC,MAAM,EAAE,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAC,EACxD,SAAS,CAAC,EAAE,SAAS;IAWvB;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,GAAE,OAAc,GAAG,MAAM,EAAE;IAoDpD;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW;IA6D7C;;;;OAIG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IAkBhC;;;;;KAKC;IACK,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBvD;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,oCAAoC,CACzC,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,MAAM,GACpB;QAAE,UAAU,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;IAOhD;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;QACrB,IAAI,EAAE,YAAY,CAAC;QACnB,YAAY,EAAE,YAAY,CAAC;QAC3B,OAAO,EAAE,SAAS,CAAC;QACnB,SAAS,EAAE,SAAS,CAAC;QACrB,kBAAkB,EAAE,cAAc,CAAC;QACnC,MAAM,EAAE,MAAM,CAAC,gCAAgC,EAAE,YAAY,CAAC,CAAC;QAC/D,SAAS,CAAC,EAAE,SAAS,CAAA;KACtB,GAAG,WAAW;CAahB"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/MasterCertificate.d.ts

@@ -1,108 +0,0 @@
-import { Base64String, CertificateFieldNameUnder50Bytes, HexString, OutpointString, PubKeyHex, WalletCounterparty } from '../../wallet/Wallet.interfaces.js';
-import Certificate from './Certificate.js';
-import ProtoWallet from '../../wallet/ProtoWallet.js';
-interface CreateCertificateFieldsResult {
-    certificateFields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-    masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-}
-/**
- * MasterCertificate extends the base Certificate class to manage a master keyring, enabling the creation of verifiable certificates.
- *
- * It allows for the selective disclosure of certificate fields by creating a `VerifiableCertificate` for a specific verifier.
- * The `MasterCertificate` can securely decrypt each master key and re-encrypt it for a verifier, creating a customized
- * keyring containing only the keys necessary for the verifier to access designated fields.
- *
- */
-export declare class MasterCertificate extends Certificate {
-    type: Base64String;
-    serialNumber: Base64String;
-    subject: PubKeyHex;
-    certifier: PubKeyHex;
-    revocationOutpoint: OutpointString;
-    fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-    signature?: HexString;
-    masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-    constructor(type: Base64String, serialNumber: Base64String, subject: PubKeyHex, certifier: PubKeyHex, revocationOutpoint: OutpointString, fields: Record<CertificateFieldNameUnder50Bytes, Base64String>, masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>, signature?: HexString);
-    /**
-     * Encrypts certificate fields for a subject and generates a master keyring.
-     * This method returns a master keyring tied to a specific certifier or subject who will validate
-     * and sign off on the fields, along with the encrypted certificate fields.
-     *
-     * @param {ProtoWallet} creatorWallet - The wallet of the creator responsible for encrypting the fields.
-     * @param {WalletCounterparty} certifierOrSubject - The certifier or subject who will validate the certificate fields.
-     * @param {Record<CertificateFieldNameUnder50Bytes, string>} fields - A record of certificate field names (under 50 bytes) mapped to their values.
-     * @param {BooleanDefaultFalse} [privileged] - Whether this is a privileged request.
-     * @param {DescriptionString5to50Bytes} [privilegedReason] - Reason provided for privileged access, required if this is a privileged operation.   *
-     * @returns {Promise<CreateCertificateFieldsResult>} A promise resolving to an object containing:
-     *   - `certificateFields` {Record<CertificateFieldNameUnder50Bytes, Base64String>}:
-     *     The encrypted certificate fields.
-     *   - `masterKeyring` {Record<CertificateFieldNameUnder50Bytes, Base64String>}:
-     *     The master keyring containing encrypted revelation keys for each field.
-     */
-    static createCertificateFields(creatorWallet: ProtoWallet, certifierOrSubject: WalletCounterparty, fields: Record<CertificateFieldNameUnder50Bytes, string>, privileged?: boolean, privilegedReason?: string): Promise<CreateCertificateFieldsResult>;
-    /**
-     * Creates a keyring for a verifier, enabling them to decrypt specific certificate fields.
-     * This method decrypts the master field keys for the specified fields and re-encrypts them
-     * for the verifier's identity key. The result is a keyring containing the keys necessary
-     * for the verifier to access the designated fields.
-     *
-     * @param {ProtoWallet} subjectWallet - The wallet instance of the subject, used to decrypt and re-encrypt field keys.
-     * @param {WalletCounterparty} verifier - The verifier who will receive access to the selectively revealed fields. Can be an identity key as hex, 'anyone', or 'self'.
-     * @param {string[]} fieldsToReveal - An array of field names to be revealed to the verifier. Must be a subset of the certificate's fields.
-     * @param {string} [originator] - Optional originator identifier, used if additional context is needed for decryption and encryption operations.
-     * @returns {Promise<Record<CertificateFieldNameUnder50Bytes, string>>} - A keyring mapping field names to encrypted field revelation keys, allowing the verifier to decrypt specified fields.
-     * @param {BooleanDefaultFalse} [privileged] - Whether this is a privileged request.
-     * @param {DescriptionString5to50Bytes} [privilegedReason] - Reason provided for privileged access, required if this is a privileged operation.   *
-     * @throws {Error} Throws an error if:
-     *   - fieldsToReveal is not an array of strings.
-     *   - A field in `fieldsToReveal` does not exist in the certificate.
-     *   - The decrypted master field key fails to decrypt the corresponding field (indicating an invalid key).
-     */
-    static createKeyringForVerifier(subjectWallet: ProtoWallet, certifier: WalletCounterparty, verifier: WalletCounterparty, fields: Record<CertificateFieldNameUnder50Bytes, Base64String>, fieldsToReveal: string[], masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>, serialNumber: Base64String, privileged?: boolean, privilegedReason?: string): Promise<Record<CertificateFieldNameUnder50Bytes, string>>;
-    /**
-     * Issues a new MasterCertificate for a specified subject.
-     *
-     * This method generates a certificate containing encrypted fields and a keyring
-     * for the subject to decrypt all fields. Each field is encrypted with a randomly
-     * generated symmetric key, which is then encrypted for the subject. The certificate
-     * can also includes a revocation outpoint to manage potential revocation.
-     *
-     * @param {ProtoWallet} certifierWallet - The wallet of the certifier, used to sign the certificate and encrypt field keys.
-     * @param {WalletCounterparty} subject - The subject for whom the certificate is issued.
-     * @param {Record<CertificateFieldNameUnder50Bytes, string>} fields - Unencrypted certificate fields to include, with their names and values.
-     * @param {string} certificateType - The type of certificate being issued.
-     * @param {function(string, Record<CertificateFieldNameUnder50Bytes, string>?): Promise<string>} getRevocationOutpoint -
-     *   Optional function to obtain a revocation outpoint for the certificate. Defaults to a placeholder.
-     * @param {function(string): Promise<void>} updateProgress - Optional callback for reporting progress updates during the operation. Defaults to a no-op.
-     * @returns {Promise<MasterCertificate>} - A signed MasterCertificate instance containing the encrypted fields and subject specific keyring.
-     *
-     * @throws {Error} Throws an error if any operation (e.g., encryption, signing) fails during certificate issuance.
-     */
-    static issueCertificateForSubject(certifierWallet: ProtoWallet, subject: WalletCounterparty, fields: Record<CertificateFieldNameUnder50Bytes, string>, certificateType: string, getRevocationOutpoint?: (_serial: string) => Promise<string>, serialNumber?: string): Promise<MasterCertificate>;
-    /**
-     * Decrypts all fields in the MasterCertificate using the subject's or certifier's wallet.
-     *
-     * This method allows the subject or certifier to decrypt the `masterKeyring` and retrieve
-     * the encryption keys for each field, which are then used to decrypt the corresponding field values.
-     * The counterparty used for decryption depends on how the certificate fields were created:
-     * - If the certificate is self-signed, the counterparty should be set to 'self'.
-     * - Otherwise, the counterparty should always be the other party involved in the certificate issuance process (the subject or certifier).
-     *
-     * @param {ProtoWallet} subjectOrCertifierWallet - The wallet of the subject or certifier, used to decrypt the master keyring and field values.
-     * @param {Record<CertificateFieldNameUnder50Bytes, Base64String>} masterKeyring - A record containing encrypted keys for each field.
-     * @param {Record<CertificateFieldNameUnder50Bytes, Base64String>} fields - A record of encrypted field names and their values.
-     * @param {WalletCounterparty} counterparty - The counterparty responsible for creating or signing the certificate. For self-signed certificates, use 'self'.
-     * @param {BooleanDefaultFalse} [privileged] - Whether this is a privileged request.
-     * @param {DescriptionString5to50Bytes} [privilegedReason] - Reason provided for privileged access, required if this is a privileged operation.
-     * @returns {Promise<Record<CertificateFieldNameUnder50Bytes, string>>} A promise resolving to a record of field names and their decrypted values in plaintext.
-     *
-     * @throws {Error} Throws an error if the `masterKeyring` is invalid or if decryption fails for any field.
-     */
-    static decryptFields(subjectOrCertifierWallet: ProtoWallet, masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>, fields: Record<CertificateFieldNameUnder50Bytes, Base64String>, counterparty: WalletCounterparty, privileged?: boolean, privilegedReason?: string): Promise<Record<CertificateFieldNameUnder50Bytes, string>>;
-    static decryptField(subjectOrCertifierWallet: ProtoWallet, masterKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>, fieldName: Base64String, fieldValue: Base64String, counterparty: WalletCounterparty, privileged?: boolean, privilegedReason?: string): Promise<{
-        fieldRevelationKey: number[];
-        decryptedFieldValue: string;
-    }>;
-}
-export {};
-//# sourceMappingURL=MasterCertificate.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/MasterCertificate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MasterCertificate.d.ts","sourceRoot":"","sources":["../../../../../src/auth/certificates/MasterCertificate.ts"],"names":[],"mappings":"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"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/VerifiableCertificate.d.ts

@@ -1,37 +0,0 @@
-import type { PubKeyHex, Base64String, CertificateFieldNameUnder50Bytes, HexString, OutpointString, WalletCertificate, OriginatorDomainNameStringUnder250Bytes } from '../../wallet/Wallet.interfaces.js';
-import ProtoWallet from '../../wallet/ProtoWallet.js';
-import Certificate from './Certificate.js';
-/**
- * VerifiableCertificate extends the Certificate class, adding functionality to manage a verifier-specific keyring.
- * This keyring allows selective decryption of certificate fields for authorized verifiers.
- */
-export declare class VerifiableCertificate extends Certificate {
-    type: Base64String;
-    serialNumber: Base64String;
-    subject: PubKeyHex;
-    certifier: PubKeyHex;
-    revocationOutpoint: OutpointString;
-    fields: Record<CertificateFieldNameUnder50Bytes, string>;
-    signature?: HexString;
-    keyring: Record<CertificateFieldNameUnder50Bytes, string>;
-    decryptedFields?: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-    constructor(type: Base64String, serialNumber: Base64String, subject: PubKeyHex, certifier: PubKeyHex, revocationOutpoint: OutpointString, fields: Record<CertificateFieldNameUnder50Bytes, string>, keyring: Record<CertificateFieldNameUnder50Bytes, string>, signature?: HexString, decryptedFields?: Record<CertificateFieldNameUnder50Bytes, Base64String>);
-    /**
-     *
-     * @param {WalletCertificate} certificate – The source certificate that was issued and signed by the certifier.
-     * @param {Record<CertificateFieldNameUnder50Bytes, string>} keyring – A allows the verifier to decrypt selected certificate fields.
-     * @returns {VerifiableCertificate} – A fully-formed instance containing the
-     *   original certificate data plus the supplied keyring.
-     */
-    static fromCertificate(certificate: WalletCertificate, keyring: Record<CertificateFieldNameUnder50Bytes, string>): VerifiableCertificate;
-    /**
-     * Decrypts selectively revealed certificate fields using the provided keyring and verifier wallet
-     * @param {ProtoWallet} verifierWallet - The wallet instance of the certificate's verifier, used to decrypt field keys.
-     * @returns {Promise<Record<CertificateFieldNameUnder50Bytes, string>>} - A promise that resolves to an object where each key is a field name and each value is the decrypted field value as a string.
-     * @param {BooleanDefaultFalse} [privileged] - Whether this is a privileged request.
-     * @param {DescriptionString5to50Bytes} [privilegedReason] - Reason provided for privileged access, required if this is a privileged operation.
-     * @throws {Error} Throws an error if any of the decryption operations fail, with a message indicating the failure context.
-     */
-    decryptFields(verifierWallet: ProtoWallet, privileged?: boolean, privilegedReason?: string, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<Record<CertificateFieldNameUnder50Bytes, string>>;
-}
-//# sourceMappingURL=VerifiableCertificate.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/VerifiableCertificate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VerifiableCertificate.d.ts","sourceRoot":"","sources":["../../../../../src/auth/certificates/VerifiableCertificate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,gCAAgC,EAChC,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,uCAAuC,EACxC,MAAM,mCAAmC,CAAA;AAG1C,OAAO,WAAW,MAAM,6BAA6B,CAAA;AACrD,OAAO,WAAW,MAAM,kBAAkB,CAAA;AAE1C;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;IAC5C,IAAI,EAAE,YAAY,CAAA;IAClB,YAAY,EAAE,YAAY,CAAA;IAC1B,OAAO,EAAE,SAAS,CAAA;IAClB,SAAS,EAAE,SAAS,CAAA;IACpB,kBAAkB,EAAE,cAAc,CAAA;IAClC,MAAM,EAAE,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAC,CAAA;IACxD,SAAS,CAAC,EAAE,SAAS,CAAA;IAE7B,OAAO,EAAE,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAC,CAAA;IACzD,eAAe,CAAC,EAAE,MAAM,CAAC,gCAAgC,EAAE,YAAY,CAAC,CAAA;gBAGtE,IAAI,EAAE,YAAY,EAClB,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,SAAS,EAClB,SAAS,EAAE,SAAS,EACpB,kBAAkB,EAAE,cAAc,EAClC,MAAM,EAAE,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAC,EACxD,OAAO,EAAE,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAC,EACzD,SAAS,CAAC,EAAE,SAAS,EACrB,eAAe,CAAC,EAAE,MAAM,CAAC,gCAAgC,EAAE,YAAY,CAAC;IAe1E;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CACpB,WAAW,EAAE,iBAAiB,EAC9B,OAAO,EAAE,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAC,GACxD,qBAAqB;IAaxB;;;;;;;OAOG;IACG,aAAa,CACjB,cAAc,EAAE,WAAW,EAC3B,UAAU,CAAC,EAAE,OAAO,EACpB,gBAAgB,CAAC,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,uCAAuC,GACnD,OAAO,CAAC,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAC,CAAC;CAkC7D"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/__tests/CompletedProtoWallet.d.ts

@@ -1,29 +0,0 @@
-import PrivateKey from '../../../primitives/PrivateKey.js';
-import { ProtoWallet, WalletInterface, CreateActionResult, SignActionResult, AbortActionResult, ListActionsResult, InternalizeActionResult, ListOutputsResult, RelinquishOutputResult, AcquireCertificateResult, ListCertificatesResult, ProveCertificateResult, RelinquishCertificateResult, DiscoverCertificatesResult, GetHeightResult, GetHeaderResult, KeyDeriverApi, KeyDeriver, GetPublicKeyArgs, PubKeyHex, AuthenticatedResult, GetNetworkResult, GetVersionResult } from '../../../wallet/index.js';
-export declare class CompletedProtoWallet extends ProtoWallet implements WalletInterface {
-    keyDeriver: KeyDeriver;
-    constructor(rootKeyOrKeyDeriver: PrivateKey | 'anyone' | KeyDeriverApi);
-    isAuthenticated(): Promise<AuthenticatedResult>;
-    waitForAuthentication(): Promise<AuthenticatedResult>;
-    getNetwork(): Promise<GetNetworkResult>;
-    getVersion(): Promise<GetVersionResult>;
-    getPublicKey(args: GetPublicKeyArgs): Promise<{
-        publicKey: PubKeyHex;
-    }>;
-    createAction(): Promise<CreateActionResult>;
-    signAction(): Promise<SignActionResult>;
-    abortAction(): Promise<AbortActionResult>;
-    listActions(): Promise<ListActionsResult>;
-    internalizeAction(): Promise<InternalizeActionResult>;
-    listOutputs(): Promise<ListOutputsResult>;
-    relinquishOutput(): Promise<RelinquishOutputResult>;
-    acquireCertificate(): Promise<AcquireCertificateResult>;
-    listCertificates(): Promise<ListCertificatesResult>;
-    proveCertificate(): Promise<ProveCertificateResult>;
-    relinquishCertificate(): Promise<RelinquishCertificateResult>;
-    discoverByIdentityKey(): Promise<DiscoverCertificatesResult>;
-    discoverByAttributes(): Promise<DiscoverCertificatesResult>;
-    getHeight(): Promise<GetHeightResult>;
-    getHeaderForHeight(): Promise<GetHeaderResult>;
-}
-//# sourceMappingURL=CompletedProtoWallet.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/__tests/CompletedProtoWallet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CompletedProtoWallet.d.ts","sourceRoot":"","sources":["../../../../../../src/auth/certificates/__tests/CompletedProtoWallet.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,mCAAmC,CAAA;AAC1D,OAAO,EACL,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,EACtB,2BAA2B,EAC3B,0BAA0B,EAC1B,eAAe,EACf,eAAe,EACf,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,SAAS,EACT,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAEjB,MAAM,0BAA0B,CAAA;AAIjC,qBAAa,oBACX,SAAQ,WACR,YAAW,eAAe;IAC1B,UAAU,EAAE,UAAU,CAAA;gBACV,mBAAmB,EAAE,UAAU,GAAG,QAAQ,GAAG,aAAa;IAehE,eAAe,IAClB,OAAO,CAAC,mBAAmB,CAAC;IAIzB,qBAAqB,IAExB,OAAO,CAAC,mBAAmB,CAAC;IAIzB,UAAU,IAEb,OAAO,CAAC,gBAAgB,CAAC;IAItB,UAAU,IAEb,OAAO,CAAC,gBAAgB,CAAC;IAItB,YAAY,CAChB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE,CAAC;IAqC9B,YAAY,IAEf,OAAO,CAAC,kBAAkB,CAAC;IAIxB,UAAU,IAEb,OAAO,CAAC,gBAAgB,CAAC;IAItB,WAAW,IAEd,OAAO,CAAC,iBAAiB,CAAC;IAIvB,WAAW,IAEd,OAAO,CAAC,iBAAiB,CAAC;IAIvB,iBAAiB,IAEpB,OAAO,CAAC,uBAAuB,CAAC;IAI7B,WAAW,IAEd,OAAO,CAAC,iBAAiB,CAAC;IAIvB,gBAAgB,IAEnB,OAAO,CAAC,sBAAsB,CAAC;IAI5B,kBAAkB,IAErB,OAAO,CAAC,wBAAwB,CAAC;IAI9B,gBAAgB,IAEnB,OAAO,CAAC,sBAAsB,CAAC;IAI5B,gBAAgB,IAEnB,OAAO,CAAC,sBAAsB,CAAC;IAI5B,qBAAqB,IAExB,OAAO,CAAC,2BAA2B,CAAC;IAIjC,qBAAqB,IAExB,OAAO,CAAC,0BAA0B,CAAC;IAIhC,oBAAoB,IAEvB,OAAO,CAAC,0BAA0B,CAAC;IAIhC,SAAS,IAEZ,OAAO,CAAC,eAAe,CAAC;IAIrB,kBAAkB,IAErB,OAAO,CAAC,eAAe,CAAC;CAG5B"}

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/index.d.ts

@@ -1,5 +0,0 @@
-export { default as Certificate } from './Certificate.js';
-export * from './MasterCertificate.js';
-export * from './VerifiableCertificate.js';
-export * from './__tests/CompletedProtoWallet.js';
-//# sourceMappingURL=index.d.ts.map

package/mobile/node_modules/@bsv/sdk/dist/types/src/auth/certificates/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/auth/certificates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACzD,cAAc,wBAAwB,CAAA;AACtC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mCAAmC,CAAA"}