@bsv/sdk 1.2.0 → 1.2.1

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "type": "commonjs",
   "description": "BSV Blockchain Software Development Kit",
   "files": [

package/docs/overlay-tools.md

@@ -522,28 +522,14 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 ---
 ## Variables
 
-| |
-| --- |
-| [DEFAULT_SHIP_TRACKERS](#variable-default_ship_trackers) |
-| [DEFAULT_SLAP_TRACKERS](#variable-default_slap_trackers) |
-
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
-
----
-
 ### Variable: DEFAULT_SLAP_TRACKERS
 
 ```ts
-DEFAULT_SLAP_TRACKERS: string[] = []
-```
-
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
-
----
-### Variable: DEFAULT_SHIP_TRACKERS
-
-```ts
-DEFAULT_SHIP_TRACKERS: string[] = []
+DEFAULT_SLAP_TRACKERS: string[] = [
+    "https://overlay.babbage.systems",
+    "https://overlay-example.babbage.systems",
+    "https://office.babbage.systems"
+]
 ```
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)

package/docs/wallet.md

@@ -1538,6 +1538,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 ```ts
 export class WalletError extends Error {
     code: number;
+    isError: boolean = true;
     constructor(message: string, code = 1, stack?: string) 
 }
 ```
@@ -2430,448 +2431,6 @@ export default class WindowCWISubstrate implements Wallet {
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
----
-### Class: XDMSubstrate
-
-Facilitates wallet operations over cross-document messaging.
-
-```ts
-export default class XDMSubstrate implements Wallet {
-    constructor() 
-    async invoke(call, args): Promise<any> 
-    async createAction(args: {
-        description: DescriptionString5to50Bytes;
-        inputs?: Array<{
-            tx?: BEEF;
-            outpoint: OutpointString;
-            unlockingScript?: HexString;
-            unlockingScriptLength?: PositiveInteger;
-            inputDescription: DescriptionString5to50Bytes;
-            sequenceNumber?: PositiveIntegerOrZero;
-        }>;
-        outputs?: Array<{
-            lockingScript: HexString;
-            satoshis: SatoshiValue;
-            outputDescription: DescriptionString5to50Bytes;
-            basket?: BasketStringUnder300Bytes;
-            customInstructions?: string;
-            tags?: OutputTagStringUnder300Bytes[];
-        }>;
-        lockTime?: PositiveIntegerOrZero;
-        version?: PositiveIntegerOrZero;
-        labels?: LabelStringUnder300Bytes[];
-        options?: {
-            signAndProcess?: BooleanDefaultTrue;
-            acceptDelayedBroadcast?: BooleanDefaultTrue;
-            trustSelf?: "known";
-            knownTxids?: TXIDHexString[];
-            returnTXIDOnly?: BooleanDefaultFalse;
-            noSend?: BooleanDefaultFalse;
-            noSendChange?: OutpointString[];
-            sendWith?: TXIDHexString[];
-        };
-    }): Promise<{
-        txid?: TXIDHexString;
-        tx?: BEEF;
-        noSendChange?: OutpointString[];
-        sendWithResults?: Array<{
-            txid: TXIDHexString;
-            status: "unproven" | "sending" | "failed";
-        }>;
-        signableTransaction?: {
-            tx: BEEF;
-            reference: Base64String;
-        };
-    }> 
-    async signAction(args: {
-        spends: Record<PositiveIntegerOrZero, {
-            unlockingScript: HexString;
-            sequenceNumber?: PositiveIntegerOrZero;
-        }>;
-        reference: Base64String;
-        options?: {
-            acceptDelayedBroadcast?: BooleanDefaultTrue;
-            returnTXIDOnly?: BooleanDefaultFalse;
-            noSend?: BooleanDefaultFalse;
-            noSendChange?: OutpointString[];
-            sendWith: TXIDHexString[];
-        };
-    }): Promise<{
-        txid?: TXIDHexString;
-        tx?: BEEF;
-        noSendChange?: OutpointString[];
-        sendWithResults?: Array<{
-            txid: TXIDHexString;
-            status: "unproven" | "sending" | "failed";
-        }>;
-    }> 
-    async abortAction(args: {
-        reference: Base64String;
-    }): Promise<{
-        aborted: true;
-    }> 
-    async listActions(args: {
-        labels: LabelStringUnder300Bytes[];
-        labelQueryMode?: "any" | "all";
-        includeLabels?: BooleanDefaultFalse;
-        includeInputs?: BooleanDefaultFalse;
-        includeInputSourceLockingScripts?: BooleanDefaultFalse;
-        includeInputUnlockingScripts?: BooleanDefaultFalse;
-        includeOutputs?: BooleanDefaultFalse;
-        includeOutputLockingScripts?: BooleanDefaultFalse;
-        limit?: PositiveIntegerDefault10Max10000;
-        offset?: PositiveIntegerOrZero;
-    }): Promise<{
-        totalActions: PositiveIntegerOrZero;
-        actions: Array<{
-            txid: TXIDHexString;
-            satoshis: SatoshiValue;
-            status: "completed" | "unprocessed" | "sending" | "unproven" | "unsigned" | "nosend" | "nonfinal";
-            isOutgoing: boolean;
-            description: DescriptionString5to50Bytes;
-            labels?: LabelStringUnder300Bytes[];
-            version: PositiveIntegerOrZero;
-            lockTime: PositiveIntegerOrZero;
-            inputs?: Array<{
-                sourceOutpoint: OutpointString;
-                sourceSatoshis: SatoshiValue;
-                sourceLockingScript?: HexString;
-                unlockingScript?: HexString;
-                inputDescription: DescriptionString5to50Bytes;
-                sequenceNumber: PositiveIntegerOrZero;
-            }>;
-            outputs?: Array<{
-                outputIndex: PositiveIntegerOrZero;
-                satoshis: SatoshiValue;
-                lockingScript?: HexString;
-                spendable: boolean;
-                outputDescription: DescriptionString5to50Bytes;
-                basket: BasketStringUnder300Bytes;
-                tags: OutputTagStringUnder300Bytes[];
-                customInstructions?: string;
-            }>;
-        }>;
-    }> 
-    async internalizeAction(args: {
-        tx: BEEF;
-        outputs: Array<{
-            outputIndex: PositiveIntegerOrZero;
-            protocol: "wallet payment" | "basket insertion";
-            paymentRemittance?: {
-                derivationPrefix: Base64String;
-                derivationSuffix: Base64String;
-                senderIdentityKey: PubKeyHex;
-            };
-            insertionRemittance?: {
-                basket: BasketStringUnder300Bytes;
-                customInstructions?: string;
-                tags?: OutputTagStringUnder300Bytes[];
-            };
-        }>;
-        description: DescriptionString5to50Bytes;
-        labels?: LabelStringUnder300Bytes[];
-    }): Promise<{
-        accepted: true;
-    }> 
-    async listOutputs(args: {
-        basket: BasketStringUnder300Bytes;
-        tags?: OutputTagStringUnder300Bytes[];
-        tagQueryMode?: "all" | "any";
-        include?: "locking scripts" | "entire transactions";
-        includeCustomInstructions?: BooleanDefaultFalse;
-        includeTags?: BooleanDefaultFalse;
-        includeLabels?: BooleanDefaultFalse;
-        limit?: PositiveIntegerDefault10Max10000;
-        offset?: PositiveIntegerOrZero;
-    }): Promise<{
-        totalOutputs: PositiveIntegerOrZero;
-        outputs: Array<{
-            outpoint: OutpointString;
-            satoshis: SatoshiValue;
-            lockingScript?: HexString;
-            tx?: BEEF;
-            spendable: true;
-            customInstructions?: string;
-            tags?: OutputTagStringUnder300Bytes[];
-            labels?: LabelStringUnder300Bytes[];
-        }>;
-    }> 
-    async relinquishOutput(args: {
-        basket: BasketStringUnder300Bytes;
-        output: OutpointString;
-    }): Promise<{
-        relinquished: true;
-    }> 
-    async getPublicKey(args: {
-        identityKey?: true;
-        protocolID?: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID?: KeyIDStringUnder800Bytes;
-        privileged?: BooleanDefaultFalse;
-        privilegedReason?: DescriptionString5to50Bytes;
-        counterparty?: PubKeyHex | "self" | "anyone";
-        forSelf?: BooleanDefaultFalse;
-    }): Promise<{
-        publicKey: PubKeyHex;
-    }> 
-    async revealCounterpartyKeyLinkage(args: {
-        counterparty: PubKeyHex;
-        verifier: PubKeyHex;
-        privilegedReason?: DescriptionString5to50Bytes;
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        prover: PubKeyHex;
-        verifier: PubKeyHex;
-        counterparty: PubKeyHex;
-        revelationTime: ISOTimestampString;
-        encryptedLinkage: Byte[];
-        encryptedLinkageProof: Byte[];
-    }> 
-    async revealSpecificKeyLinkage(args: {
-        counterparty: PubKeyHex;
-        verifier: PubKeyHex;
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        privilegedReason?: DescriptionString5to50Bytes;
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        prover: PubKeyHex;
-        verifier: PubKeyHex;
-        counterparty: PubKeyHex;
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        encryptedLinkage: Byte[];
-        encryptedLinkageProof: Byte[];
-        proofType: Byte;
-    }> 
-    async encrypt(args: {
-        plaintext: Byte[];
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        privilegedReason?: DescriptionString5to50Bytes;
-        counterparty?: PubKeyHex | "self" | "anyone";
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        ciphertext: Byte[];
-    }> 
-    async decrypt(args: {
-        ciphertext: Byte[];
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        privilegedReason?: DescriptionString5to50Bytes;
-        counterparty?: PubKeyHex | "self" | "anyone";
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        plaintext: Byte[];
-    }> 
-    async createHmac(args: {
-        data: Byte[];
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        privilegedReason?: DescriptionString5to50Bytes;
-        counterparty?: PubKeyHex | "self" | "anyone";
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        hmac: Byte[];
-    }> 
-    async verifyHmac(args: {
-        data: Byte[];
-        hmac: Byte[];
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        privilegedReason?: DescriptionString5to50Bytes;
-        counterparty?: PubKeyHex | "self" | "anyone";
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        valid: true;
-    }> 
-    async createSignature(args: {
-        data?: Byte[];
-        hashToDirectlySign?: Byte[];
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        privilegedReason?: DescriptionString5to50Bytes;
-        counterparty?: PubKeyHex | "self" | "anyone";
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        signature: Byte[];
-    }> 
-    async verifySignature(args: {
-        data?: Byte[];
-        hashToDirectlyVerify?: Byte[];
-        signature: Byte[];
-        protocolID: [
-            0 | 1 | 2,
-            ProtocolString5To400Bytes
-        ];
-        keyID: KeyIDStringUnder800Bytes;
-        privilegedReason?: DescriptionString5to50Bytes;
-        counterparty?: PubKeyHex | "self" | "anyone";
-        forSelf?: BooleanDefaultFalse;
-        privileged?: BooleanDefaultFalse;
-    }): Promise<{
-        valid: true;
-    }> 
-    async acquireCertificate(args: {
-        type: Base64String;
-        subject: PubKeyHex;
-        serialNumber: Base64String;
-        revocationOutpoint: OutpointString;
-        signature: HexString;
-        fields: Record<CertificateFieldNameUnder50Bytes, string>;
-        certifier: PubKeyHex;
-        keyringRevealer: PubKeyHex | "certifier";
-        keyringForSubject: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-        acquisitionProtocol: "direct" | "issuance";
-        certifierUrl?: string;
-    }): Promise<{
-        type: Base64String;
-        subject: PubKeyHex;
-        serialNumber: Base64String;
-        certifier: PubKeyHex;
-        revocationOutpoint: OutpointString;
-        signature: HexString;
-        fields: Record<CertificateFieldNameUnder50Bytes, string>;
-    }> 
-    async listCertificates(args: {
-        certifiers: PubKeyHex[];
-        types: Base64String[];
-        limit?: PositiveIntegerDefault10Max10000;
-        offset?: PositiveIntegerOrZero;
-        privileged?: BooleanDefaultFalse;
-        privilegedReason?: DescriptionString5to50Bytes;
-    }): Promise<{
-        totalCertificates: PositiveIntegerOrZero;
-        certificates: Array<{
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, string>;
-        }>;
-    }> 
-    async proveCertificate(args: {
-        certificate: {
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, string>;
-        };
-        fieldsToReveal: CertificateFieldNameUnder50Bytes[];
-        verifier: PubKeyHex;
-        privileged?: BooleanDefaultFalse;
-        privilegedReason?: DescriptionString5to50Bytes;
-    }): Promise<{
-        keyringForVerifier: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-    }> 
-    async relinquishCertificate(args: {
-        type: Base64String;
-        serialNumber: Base64String;
-        certifier: PubKeyHex;
-    }): Promise<{
-        relinquished: true;
-    }> 
-    async discoverByIdentityKey(args: {
-        identityKey: PubKeyHex;
-        limit?: PositiveIntegerDefault10Max10000;
-        offset?: PositiveIntegerOrZero;
-    }): Promise<{
-        totalCertificates: PositiveIntegerOrZero;
-        certificates: Array<{
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            certifierInfo: {
-                name: EntityNameStringMax100Bytes;
-                iconUrl: EntityIconURLStringMax500Bytes;
-                description: DescriptionString5to50Bytes;
-                trust: PositiveIntegerMax10;
-            };
-            publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
-        }>;
-    }> 
-    async discoverByAttributes(args: {
-        attributes: Record<CertificateFieldNameUnder50Bytes, string>;
-        limit?: PositiveIntegerDefault10Max10000;
-        offset?: PositiveIntegerOrZero;
-    }): Promise<{
-        totalCertificates: PositiveIntegerOrZero;
-        certificates: Array<{
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            certifierInfo: {
-                name: EntityNameStringMax100Bytes;
-                iconUrl: EntityIconURLStringMax500Bytes;
-                description: DescriptionString5to50Bytes;
-                trust: PositiveIntegerMax10;
-            };
-            publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
-        }>;
-    }> 
-    async isAuthenticated(args: {}): Promise<{
-        authenticated: boolean;
-    }> 
-    async waitForAuthentication(args: {}): Promise<{
-        authenticated: true;
-    }> 
-    async getHeight(args: {}): Promise<{
-        height: PositiveInteger;
-    }> 
-    async getHeaderForHeight(args: {
-        height: PositiveInteger;
-    }): Promise<{
-        header: HexString;
-    }> 
-    async getNetwork(args: {}): Promise<{
-        network: "mainnet" | "testnet";
-    }> 
-    async getVersion(args: {}): Promise<{
-        version: VersionString7To30Bytes;
-    }> 
-}
-```
-
-Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
-
 ---
 ### Class: WalletWireTransceiver
 
@@ -2881,167 +2440,18 @@ A way to make remote calls to a wallet over a wallet wire.
 export default class WalletWireTransceiver implements Wallet {
     wire: WalletWire;
     constructor(wire: WalletWire) 
-    async createAction(args: {
-        description: DescriptionString5to50Bytes;
-        inputBEEF?: BEEF;
-        inputs?: Array<{
-            outpoint: OutpointString;
-            unlockingScript?: HexString;
-            unlockingScriptLength?: PositiveInteger;
-            inputDescription: DescriptionString5to50Bytes;
-            sequenceNumber?: PositiveIntegerOrZero;
-        }>;
-        outputs?: Array<{
-            lockingScript: HexString;
-            satoshis: SatoshiValue;
-            outputDescription: DescriptionString5to50Bytes;
-            basket?: BasketStringUnder300Bytes;
-            customInstructions?: string;
-            tags?: OutputTagStringUnder300Bytes[];
-        }>;
-        lockTime?: PositiveIntegerOrZero;
-        version?: PositiveIntegerOrZero;
-        labels?: LabelStringUnder300Bytes[];
-        options?: {
-            signAndProcess?: BooleanDefaultTrue;
-            acceptDelayedBroadcast?: BooleanDefaultTrue;
-            trustSelf?: "known";
-            knownTxids?: TXIDHexString[];
-            returnTXIDOnly?: BooleanDefaultFalse;
-            noSend?: BooleanDefaultFalse;
-            noSendChange?: OutpointString[];
-            sendWith?: TXIDHexString[];
-            randomizeOutputs?: BooleanDefaultTrue;
-        };
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        txid?: TXIDHexString;
-        tx?: BEEF;
-        noSendChange?: OutpointString[];
-        sendWithResults?: Array<{
-            txid: TXIDHexString;
-            status: "unproven" | "sending" | "failed";
-        }>;
-        signableTransaction?: {
-            tx: BEEF;
-            reference: Base64String;
-        };
-    }> 
-    async signAction(args: {
-        spends: Record<PositiveIntegerOrZero, {
-            unlockingScript: HexString;
-            sequenceNumber?: PositiveIntegerOrZero;
-        }>;
-        reference: Base64String;
-        options?: {
-            acceptDelayedBroadcast?: BooleanDefaultTrue;
-            returnTXIDOnly?: BooleanDefaultFalse;
-            noSend?: BooleanDefaultFalse;
-            noSendChange?: OutpointString[];
-            sendWith: TXIDHexString[];
-        };
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        txid?: TXIDHexString;
-        tx?: BEEF;
-        noSendChange?: OutpointString[];
-        sendWithResults?: Array<{
-            txid: TXIDHexString;
-            status: "unproven" | "sending" | "failed";
-        }>;
-    }> 
+    async createAction(args: CreateActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<CreateActionResult> 
+    async signAction(args: SignActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<SignActionResult> 
     async abortAction(args: {
         reference: Base64String;
     }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
         aborted: true;
     }> 
-    async listActions(args: {
-        seekPermission?: BooleanDefaultTrue;
-        labels: LabelStringUnder300Bytes[];
-        labelQueryMode?: "any" | "all";
-        includeLabels?: BooleanDefaultFalse;
-        includeInputs?: BooleanDefaultFalse;
-        includeInputSourceLockingScripts?: BooleanDefaultFalse;
-        includeInputUnlockingScripts?: BooleanDefaultFalse;
-        includeOutputs?: BooleanDefaultFalse;
-        includeOutputLockingScripts?: BooleanDefaultFalse;
-        limit?: PositiveIntegerDefault10Max10000;
-        offset?: PositiveIntegerOrZero;
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        totalActions: PositiveIntegerOrZero;
-        actions: Array<{
-            txid: TXIDHexString;
-            satoshis: SatoshiValue;
-            status: "completed" | "unprocessed" | "sending" | "unproven" | "unsigned" | "nosend" | "nonfinal";
-            isOutgoing: boolean;
-            description: DescriptionString5to50Bytes;
-            labels?: LabelStringUnder300Bytes[];
-            version: PositiveIntegerOrZero;
-            lockTime: PositiveIntegerOrZero;
-            inputs?: Array<{
-                sourceOutpoint: OutpointString;
-                sourceSatoshis: SatoshiValue;
-                sourceLockingScript?: HexString;
-                unlockingScript?: HexString;
-                inputDescription: DescriptionString5to50Bytes;
-                sequenceNumber: PositiveIntegerOrZero;
-            }>;
-            outputs?: Array<{
-                outputIndex: PositiveIntegerOrZero;
-                satoshis: SatoshiValue;
-                lockingScript?: HexString;
-                spendable: boolean;
-                outputDescription: DescriptionString5to50Bytes;
-                basket: BasketStringUnder300Bytes;
-                tags: OutputTagStringUnder300Bytes[];
-                customInstructions?: string;
-            }>;
-        }>;
-    }> 
-    async internalizeAction(args: {
-        seekPermission?: BooleanDefaultTrue;
-        tx: AtomicBEEF;
-        outputs: Array<{
-            outputIndex: PositiveIntegerOrZero;
-            protocol: "wallet payment" | "basket insertion";
-            paymentRemittance?: {
-                derivationPrefix: Base64String;
-                derivationSuffix: Base64String;
-                senderIdentityKey: PubKeyHex;
-            };
-            insertionRemittance?: {
-                basket: BasketStringUnder300Bytes;
-                customInstructions?: string;
-                tags?: OutputTagStringUnder300Bytes[];
-            };
-        }>;
-        description: DescriptionString5to50Bytes;
-        labels?: LabelStringUnder300Bytes[];
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
+    async listActions(args: ListActionsArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ListActionsResult> 
+    async internalizeAction(args: InternalizeActionArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
         accepted: true;
     }> 
-    async listOutputs(args: {
-        seekPermission?: BooleanDefaultTrue;
-        basket: BasketStringUnder300Bytes;
-        tags?: OutputTagStringUnder300Bytes[];
-        tagQueryMode?: "all" | "any";
-        include?: "locking scripts" | "entire transactions";
-        includeCustomInstructions?: BooleanDefaultFalse;
-        includeTags?: BooleanDefaultFalse;
-        includeLabels?: BooleanDefaultFalse;
-        limit?: PositiveIntegerDefault10Max10000;
-        offset?: PositiveIntegerOrZero;
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        totalOutputs: PositiveIntegerOrZero;
-        BEEF?: BEEF;
-        outputs: Array<{
-            outpoint: OutpointString;
-            satoshis: SatoshiValue;
-            lockingScript?: HexString;
-            spendable: true;
-            customInstructions?: string;
-            tags?: OutputTagStringUnder300Bytes[];
-            labels?: LabelStringUnder300Bytes[];
-        }>;
-    }> 
+    async listOutputs(args: ListOutputsArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ListOutputsResult> 
     async relinquishOutput(args: {
         basket: BasketStringUnder300Bytes;
         output: OutpointString;
@@ -3188,28 +2598,7 @@ export default class WalletWireTransceiver implements Wallet {
     }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
         valid: true;
     }> 
-    async acquireCertificate(args: {
-        type: Base64String;
-        certifier: PubKeyHex;
-        acquisitionProtocol: "direct" | "issuance";
-        fields: Record<CertificateFieldNameUnder50Bytes, string>;
-        serialNumber?: Base64String;
-        revocationOutpoint?: OutpointString;
-        signature?: HexString;
-        certifierUrl?: string;
-        keyringRevealer?: PubKeyHex | "certifier";
-        keyringForSubject?: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-        privileged?: BooleanDefaultFalse;
-        privilegedReason?: DescriptionString5to50Bytes;
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        type: Base64String;
-        subject: PubKeyHex;
-        serialNumber: Base64String;
-        certifier: PubKeyHex;
-        revocationOutpoint: OutpointString;
-        signature: HexString;
-        fields: Record<CertificateFieldNameUnder50Bytes, string>;
-    }> 
+    async acquireCertificate(args: AcquireCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<AcquireCertificateResult> 
     async listCertificates(args: {
         certifiers: PubKeyHex[];
         types: Base64String[];
@@ -3217,35 +2606,8 @@ export default class WalletWireTransceiver implements Wallet {
         offset?: PositiveIntegerOrZero;
         privileged?: BooleanDefaultFalse;
         privilegedReason?: DescriptionString5to50Bytes;
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        totalCertificates: PositiveIntegerOrZero;
-        certificates: Array<{
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, string>;
-        }>;
-    }> 
-    async proveCertificate(args: {
-        certificate: {
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, string>;
-        };
-        fieldsToReveal: CertificateFieldNameUnder50Bytes[];
-        verifier: PubKeyHex;
-        privileged?: BooleanDefaultFalse;
-        privilegedReason?: DescriptionString5to50Bytes;
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        keyringForVerifier: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-    }> 
+    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ListCertificatesResult> 
+    async proveCertificate(args: ProveCertificateArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<ProveCertificateResult> 
     async relinquishCertificate(args: {
         type: Base64String;
         serialNumber: Base64String;
@@ -3258,51 +2620,13 @@ export default class WalletWireTransceiver implements Wallet {
         identityKey: PubKeyHex;
         limit?: PositiveIntegerDefault10Max10000;
         offset?: PositiveIntegerOrZero;
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        totalCertificates: PositiveIntegerOrZero;
-        certificates: Array<{
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            certifierInfo: {
-                name: EntityNameStringMax100Bytes;
-                iconUrl: EntityIconURLStringMax500Bytes;
-                description: DescriptionString5to50Bytes;
-                trust: PositiveIntegerMax10;
-            };
-            publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
-        }>;
-    }> 
+    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<DiscoverCertificatesResult> 
     async discoverByAttributes(args: {
         seekPermission?: BooleanDefaultTrue;
         attributes: Record<CertificateFieldNameUnder50Bytes, string>;
         limit?: PositiveIntegerDefault10Max10000;
         offset?: PositiveIntegerOrZero;
-    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
-        totalCertificates: PositiveIntegerOrZero;
-        certificates: Array<{
-            type: Base64String;
-            subject: PubKeyHex;
-            serialNumber: Base64String;
-            certifier: PubKeyHex;
-            revocationOutpoint: OutpointString;
-            signature: HexString;
-            fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            certifierInfo: {
-                name: EntityNameStringMax100Bytes;
-                iconUrl: EntityIconURLStringMax500Bytes;
-                description: DescriptionString5to50Bytes;
-                trust: PositiveIntegerMax10;
-            };
-            publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
-            decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
-        }>;
-    }> 
+    }, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<DiscoverCertificatesResult> 
     async isAuthenticated(args: {}, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<{
         authenticated: boolean;
     }> 
@@ -3328,6 +2652,21 @@ export default class WalletWireTransceiver implements Wallet {
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
+---
+### Class: WalletWireProcessor
+
+Processes incoming wallet calls received over a wallet wire, with a given wallet.
+
+```ts
+export default class WalletWireProcessor implements WalletWire {
+    wallet: Wallet;
+    constructor(wallet: Wallet) 
+    async transmitToWallet(message: number[]): Promise<number[]> 
+}
+```
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
+
 ---
 ### Class: HTTPWalletWire
 
@@ -3344,16 +2683,14 @@ export default class HTTPWalletWire implements WalletWire {
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Class: WalletClient
+### Class: XDMSubstrate
 
-The SDK is how applications communicate with wallets over a communications substrate.
+Facilitates wallet operations over cross-document messaging.
 
 ```ts
-export default class WalletClient implements Wallet {
-    public substrate: "auto" | Wallet;
-    originator?: OriginatorDomainNameStringUnder250Bytes;
-    constructor(substrate: "auto" | "Cicada" | "XDM" | "window.CWI" | Wallet = "auto", originator?: OriginatorDomainNameStringUnder250Bytes) 
-    async connectToSubstrate() 
+export default class XDMSubstrate implements Wallet {
+    constructor(domain: string = "*") 
+    async invoke(call: CallType, args: any): Promise<any> 
     async createAction(args: {
         description: DescriptionString5to50Bytes;
         inputs?: Array<{
@@ -3762,13 +3099,13 @@ export default class WalletClient implements Wallet {
             decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
         }>;
     }> 
-    async isAuthenticated(args: {} = {}): Promise<{
+    async isAuthenticated(args: {}): Promise<{
         authenticated: boolean;
     }> 
-    async waitForAuthentication(args: {} = {}): Promise<{
+    async waitForAuthentication(args: {}): Promise<{
         authenticated: true;
     }> 
-    async getHeight(args: {} = {}): Promise<{
+    async getHeight(args: {}): Promise<{
         height: PositiveInteger;
     }> 
     async getHeaderForHeight(args: {
@@ -3776,10 +3113,10 @@ export default class WalletClient implements Wallet {
     }): Promise<{
         header: HexString;
     }> 
-    async getNetwork(args: {} = {}): Promise<{
+    async getNetwork(args: {}): Promise<{
         network: "mainnet" | "testnet";
     }> 
-    async getVersion(args: {} = {}): Promise<{
+    async getVersion(args: {}): Promise<{
         version: VersionString7To30Bytes;
     }> 
 }
@@ -3788,15 +3125,214 @@ export default class WalletClient implements Wallet {
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 
 ---
-### Class: WalletWireProcessor
+### Class: WalletClient
 
-Processes incoming wallet calls received over a wallet wire, with a given wallet.
+The SDK is how applications communicate with wallets over a communications substrate.
 
 ```ts
-export default class WalletWireProcessor implements WalletWire {
-    wallet: Wallet;
-    constructor(wallet: Wallet) 
-    async transmitToWallet(message: number[]): Promise<number[]> 
+export default class WalletClient implements Wallet {
+    public substrate: "auto" | Wallet;
+    originator?: OriginatorDomainNameStringUnder250Bytes;
+    constructor(substrate: "auto" | "Cicada" | "XDM" | "window.CWI" | Wallet = "auto", originator?: OriginatorDomainNameStringUnder250Bytes) 
+    async connectToSubstrate() 
+    async createAction(args: CreateActionArgs): Promise<CreateActionResult> 
+    async signAction(args: SignActionArgs): Promise<SignActionResult> 
+    async abortAction(args: {
+        reference: Base64String;
+    }): Promise<{
+        aborted: true;
+    }> 
+    async listActions(args: ListActionsArgs): Promise<ListActionsResult> 
+    async internalizeAction(args: InternalizeActionArgs): Promise<{
+        accepted: true;
+    }> 
+    async listOutputs(args: ListOutputsArgs): Promise<ListOutputsResult> 
+    async relinquishOutput(args: {
+        basket: BasketStringUnder300Bytes;
+        output: OutpointString;
+    }): Promise<{
+        relinquished: true;
+    }> 
+    async getPublicKey(args: {
+        identityKey?: true;
+        protocolID?: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID?: KeyIDStringUnder800Bytes;
+        privileged?: BooleanDefaultFalse;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        forSelf?: BooleanDefaultFalse;
+    }): Promise<{
+        publicKey: PubKeyHex;
+    }> 
+    async revealCounterpartyKeyLinkage(args: {
+        counterparty: PubKeyHex;
+        verifier: PubKeyHex;
+        privilegedReason?: DescriptionString5to50Bytes;
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        prover: PubKeyHex;
+        verifier: PubKeyHex;
+        counterparty: PubKeyHex;
+        revelationTime: ISOTimestampString;
+        encryptedLinkage: Byte[];
+        encryptedLinkageProof: Byte[];
+    }> 
+    async revealSpecificKeyLinkage(args: {
+        counterparty: PubKeyHex;
+        verifier: PubKeyHex;
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        prover: PubKeyHex;
+        verifier: PubKeyHex;
+        counterparty: PubKeyHex;
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        encryptedLinkage: Byte[];
+        encryptedLinkageProof: Byte[];
+        proofType: Byte;
+    }> 
+    async encrypt(args: {
+        plaintext: Byte[];
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        ciphertext: Byte[];
+    }> 
+    async decrypt(args: {
+        ciphertext: Byte[];
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        plaintext: Byte[];
+    }> 
+    async createHmac(args: {
+        data: Byte[];
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        hmac: Byte[];
+    }> 
+    async verifyHmac(args: {
+        data: Byte[];
+        hmac: Byte[];
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        valid: true;
+    }> 
+    async createSignature(args: {
+        data?: Byte[];
+        hashToDirectlySign?: Byte[];
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        signature: Byte[];
+    }> 
+    async verifySignature(args: {
+        data?: Byte[];
+        hashToDirectlyVerify?: Byte[];
+        signature: Byte[];
+        protocolID: [
+            0 | 1 | 2,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        forSelf?: BooleanDefaultFalse;
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        valid: true;
+    }> 
+    async acquireCertificate(args: AcquireCertificateArgs): Promise<AcquireCertificateResult> 
+    async listCertificates(args: {
+        certifiers: PubKeyHex[];
+        types: Base64String[];
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+        privileged?: BooleanDefaultFalse;
+        privilegedReason?: DescriptionString5to50Bytes;
+    }): Promise<ListCertificatesResult> 
+    async proveCertificate(args: ProveCertificateArgs): Promise<ProveCertificateResult> 
+    async relinquishCertificate(args: {
+        type: Base64String;
+        serialNumber: Base64String;
+        certifier: PubKeyHex;
+    }): Promise<{
+        relinquished: true;
+    }> 
+    async discoverByIdentityKey(args: {
+        identityKey: PubKeyHex;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<DiscoverCertificatesResult> 
+    async discoverByAttributes(args: {
+        attributes: Record<CertificateFieldNameUnder50Bytes, string>;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<DiscoverCertificatesResult> 
+    async isAuthenticated(args: {} = {}): Promise<{
+        authenticated: boolean;
+    }> 
+    async waitForAuthentication(args: {} = {}): Promise<{
+        authenticated: true;
+    }> 
+    async getHeight(args: {} = {}): Promise<{
+        height: PositiveInteger;
+    }> 
+    async getHeaderForHeight(args: {
+        height: PositiveInteger;
+    }): Promise<{
+        header: HexString;
+    }> 
+    async getNetwork(args: {} = {}): Promise<{
+        network: "mainnet" | "testnet";
+    }> 
+    async getVersion(args: {} = {}): Promise<{
+        version: VersionString7To30Bytes;
+    }> 
 }
 ```
 
@@ -3809,19 +3345,19 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 | | | |
 | --- | --- | --- |
-| [AcquisitionProtocol](#type-acquisitionprotocol) | [EntityNameStringMax100Bytes](#type-entitynamestringmax100characters) | [PositiveIntegerMax10](#type-positiveintegermax10) |
-| [ActionStatus](#type-actionstatus) | [ErrorCodeString10To40Bytes](#type-errorcodestring10to40characters) | [PositiveIntegerOrZero](#type-positiveintegerorzero) |
-| [AtomicBEEF](#type-atomicbeef) | [ErrorDescriptionString20To200Bytes](#type-errordescriptionstring20to200characters) | [ProtocolString5To400Bytes](#type-protocolstring5to400characters) |
+| [AcquisitionProtocol](#type-acquisitionprotocol) | [EntityNameStringMax100Bytes](#type-entitynamestringmax100bytes) | [PositiveIntegerMax10](#type-positiveintegermax10) |
+| [ActionStatus](#type-actionstatus) | [ErrorCodeString10To40Bytes](#type-errorcodestring10to40bytes) | [PositiveIntegerOrZero](#type-positiveintegerorzero) |
+| [AtomicBEEF](#type-atomicbeef) | [ErrorDescriptionString20To200Bytes](#type-errordescriptionstring20to200bytes) | [ProtocolString5To400Bytes](#type-protocolstring5to400bytes) |
 | [BEEF](#type-beef) | [HexString](#type-hexstring) | [PubKeyHex](#type-pubkeyhex) |
 | [Base64String](#type-base64string) | [ISOTimestampString](#type-isotimestampstring) | [SatoshiValue](#type-satoshivalue) |
-| [BasketStringUnder300Bytes](#type-basketstringunder300characters) | [KeyIDStringUnder800Bytes](#type-keyidstringunder800characters) | [TXIDHexString](#type-txidhexstring) |
+| [BasketStringUnder300Bytes](#type-basketstringunder300bytes) | [KeyIDStringUnder800Bytes](#type-keyidstringunder800bytes) | [TXIDHexString](#type-txidhexstring) |
 | [BooleanDefaultFalse](#type-booleandefaultfalse) | [KeyringRevealer](#type-keyringrevealer) | [TrustSelf](#type-trustself) |
-| [BooleanDefaultTrue](#type-booleandefaulttrue) | [LabelStringUnder300Bytes](#type-labelstringunder300characters) | [VersionString7To30Bytes](#type-versionstring7to30characters) |
-| [Byte](#type-byte) | [OriginatorDomainNameStringUnder250Bytes](#type-originatordomainnamestringunder250characters) | [WalletCounterparty](#type-walletcounterparty) |
+| [BooleanDefaultTrue](#type-booleandefaulttrue) | [LabelStringUnder300Bytes](#type-labelstringunder300bytes) | [VersionString7To30Bytes](#type-versionstring7to30bytes) |
+| [Byte](#type-byte) | [OriginatorDomainNameStringUnder250Bytes](#type-originatordomainnamestringunder250bytes) | [WalletCounterparty](#type-walletcounterparty) |
 | [CallType](#type-calltype) | [OutpointString](#type-outpointstring) | [WalletErrorCode](#type-walleterrorcode) |
-| [CertificateFieldNameUnder50Bytes](#type-certificatefieldnameunder50characters) | [OutputTagStringUnder300Bytes](#type-outputtagstringunder300characters) | [WalletNetwork](#type-walletnetwork) |
-| [DescriptionString5to50Bytes](#type-descriptionstring5to50characters) | [PositiveInteger](#type-positiveinteger) | [WalletProtocol](#type-walletprotocol) |
-| [EntityIconURLStringMax500Bytes](#type-entityiconurlstringmax500characters) | [PositiveIntegerDefault10Max10000](#type-positiveintegerdefault10max10000) |  |
+| [CertificateFieldNameUnder50Bytes](#type-certificatefieldnameunder50bytes) | [OutputTagStringUnder300Bytes](#type-outputtagstringunder300bytes) | [WalletNetwork](#type-walletnetwork) |
+| [DescriptionString5to50Bytes](#type-descriptionstring5to50bytes) | [PositiveInteger](#type-positiveinteger) | [WalletProtocol](#type-walletprotocol) |
+| [EntityIconURLStringMax500Bytes](#type-entityiconurlstringmax500bytes) | [PositiveIntegerDefault10Max10000](#type-positiveintegerdefault10max10000) |  |
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Variables](#variables)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",