@bsv/wallet-toolbox 1.7.13 → 1.7.15

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

@@ -0,0 +1,200 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1 @@
+{"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"}