@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

package/dist/src/bitgo/utils/tss/baseTypes.d.ts

@@ -1,13 +1,16 @@
-/// <reference types="node" />
 import { Key, SerializedKeyPair } from 'openpgp';
-import { IRequestTracer } from '../../../api';
-import { KeychainsTriplet } from '../../baseCoin';
-import { ApiKeyShare, Keychain } from '../../keychain';
-import { ApiVersion, Memo, WalletType } from '../../wallet';
-import { EDDSA, GShare, SignShare, YShare } from '../../../account-lib/mpc/tss';
+import { EncryptionVersion, IEncryptionSession, IRequestTracer } from '../../../api';
+import { type ITransactionRecipient, KeychainsTriplet, ParsedTransaction, TransactionParams } from '../../baseCoin';
+import { ApiKeyShare, Keychain, WebauthnKeyEncryptionInfo } from '../../keychain';
+import { ApiVersion, Memo, WalletType, type PrebuildTransactionFeeInfo } from '../../wallet';
+import { EDDSA, GShare, Signature, SignShare } from '../../../account-lib/mpc/tss';
+import { Signature as EcdsaSignature } from '../../../account-lib/mpc/tss/ecdsa/types';
 import { KeyShare } from './ecdsa';
-import { Hash } from 'crypto';
-export declare type TxRequestVersion = 'full' | 'lite';
+import { EcdsaTypes } from '@bitgo-beta/sdk-lib-mpc';
+import { TssEcdsaStep1ReturnMessage, TssEcdsaStep2ReturnMessage, TxRequestChallengeResponse } from '../../tss/types';
+import { AShare, DShare, SShare } from '../../tss/ecdsa/types';
+import { MessageStandardType } from '../messageTypes';
+export type TxRequestVersion = 'full' | 'lite';
 export interface HopParams {
     paymentId?: string;
     userReqSig?: string;
@@ -15,8 +18,9 @@ export interface HopParams {
 }
 export interface EIP1559FeeOptions {
     gasLimit?: number;
-    maxFeePerGas?: number;
-    maxPriorityFeePerGas?: number;
+    maxFeePerGas: number;
+    maxPriorityFeePerGas: number;
+    feeToken?: string;
 }
 export interface FeeOption {
     unit?: 'baseUnit' | 'cpu' | 'ram';
@@ -24,17 +28,154 @@ export interface FeeOption {
     feeType?: 'base' | 'max' | 'tip';
     gasLimit?: number;
     gasPrice?: number;
+    feeToken?: string;
 }
 export interface TokenEnablement {
     name: string;
     address?: string;
 }
+export interface SolInstruction {
+    programId: string;
+    keys: Array<{
+        pubkey: string;
+        isSigner: boolean;
+        isWritable: boolean;
+    }>;
+    data: string;
+}
+export interface SolVersionedInstruction {
+    programIdIndex: number;
+    accountKeyIndexes: number[];
+    data: string;
+}
+export interface SolAddressLookupTable {
+    accountKey: string;
+    writableIndexes: number[];
+    readonlyIndexes: number[];
+}
+export type SolTransactionVersion = 0 | 1;
+export interface SolV1TransactionConfig {
+    computeUnitLimit: number | null;
+    heapSize: number | null;
+    loadedAccountsDataSizeLimit: number | null;
+    priorityFee: number | null;
+}
+export interface SolVersionedTransactionData {
+    versionedInstructions: SolVersionedInstruction[];
+    addressLookupTables: SolAddressLookupTable[];
+    staticAccountKeys: string[];
+    messageHeader: {
+        numRequiredSignatures: number;
+        numReadonlySignedAccounts: number;
+        numReadonlyUnsignedAccounts: number;
+    };
+    recentBlockhash?: string;
+    version?: SolTransactionVersion;
+    transactionConfig?: SolV1TransactionConfig;
+}
+export interface aptosCustomTransactionParams {
+    moduleName: string;
+    functionName: string;
+    typeArguments?: string[];
+    functionArguments?: any[];
+    abi?: any;
+}
+export interface CantonCreateCommand {
+    CreateCommand: {
+        templateId: string;
+        createArguments: Record<string, unknown>;
+    };
+}
+export interface CantonExerciseCommand {
+    ExerciseCommand: {
+        templateId: string;
+        contractId?: string;
+        choice: string;
+        choiceArgument?: Record<string, unknown>;
+    };
+}
+export type CantonCommand = CantonCreateCommand | CantonExerciseCommand;
+export interface CantonCommandResolveContractSpec {
+    templateId: string;
+    actAs: string[];
+    readAs?: string[];
+    injectAs: string;
+    resolveAll?: boolean;
+}
+export interface CantonCommandParams {
+    command: CantonCommand;
+    actAs: string[];
+    readAs?: string[];
+    resolveContracts?: CantonCommandResolveContractSpec[];
+}
+export declare enum ShareType {
+    R = "R",
+    Commitment = "commitment",
+    G = "G",
+    S = "S",
+    K = "K",
+    MuDelta = "MuDelta",
+    PaillierModulus = "PaillierModulus",
+    MPCv2Round1 = "MPCv2Round1",
+    MPCv2Round2 = "MPCv2Round2",
+    MPCv2Round3 = "MPCv2Round3",
+    EddsaMPCv2Round1 = "EddsaMPCv2Round1",
+    EddsaMPCv2Round2 = "EddsaMPCv2Round2",
+    EddsaMPCv2Round3 = "EddsaMPCv2Round3"
+}
+export declare enum MPCType {
+    EDDSA = "eddsa",
+    ECDSA = "ecdsa"
+}
+export interface CustomPaillierModulusGetterFunction {
+    (params: {
+        txRequest: TxRequest;
+    }): Promise<{
+        userPaillierModulus: string;
+    }>;
+}
+export interface CustomKShareGeneratingFunction {
+    (params: {
+        tssParams: TSSParams | TSSParamsForMessage;
+        challenges: {
+            enterpriseChallenge: EcdsaTypes.SerializedEcdsaChallenges;
+            bitgoChallenge: TxRequestChallengeResponse;
+        };
+        requestType: RequestType;
+    }): Promise<TssEcdsaStep1ReturnMessage>;
+}
+export interface CustomMuDeltaShareGeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+        aShareFromBitgo: Omit<AShare, 'ntilde' | 'h1' | 'h2'>;
+        bitgoChallenge: TxRequestChallengeResponse;
+        encryptedWShare: string;
+    }): Promise<TssEcdsaStep2ReturnMessage>;
+}
+export interface CustomSShareGeneratingFunction {
+    (params: {
+        tssParams: TSSParams | TSSParamsForMessage;
+        dShareFromBitgo: DShare;
+        requestType: RequestType;
+        encryptedOShare: string;
+    }): Promise<SShare>;
+}
+export interface CustomCommitmentGeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+        bitgoGpgPubKey?: string;
+    }): Promise<{
+        userToBitgoCommitment: CommitmentShareRecord;
+        encryptedSignerShare: EncryptedSignerShareRecord;
+        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
+    }>;
+}
 export interface CustomRShareGeneratingFunction {
     (params: {
         txRequest: TxRequest;
+        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
     }): Promise<{
         rShare: SignShare;
-        signingKeyYShare: YShare;
     }>;
 }
 export interface CustomGShareGeneratingFunction {
@@ -42,12 +183,76 @@ export interface CustomGShareGeneratingFunction {
         txRequest: TxRequest;
         userToBitgoRShare: SignShare;
         bitgoToUserRShare: SignatureShareRecord;
+        bitgoToUserCommitment: CommitmentShareRecord;
     }): Promise<GShare>;
 }
+export interface CustomMPCv2SigningRound1GeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+    }): Promise<{
+        signatureShareRound1: SignatureShareRecord;
+        encryptedRound1Session: string;
+        userGpgPubKey: string;
+        encryptedUserGpgPrvKey: string;
+    }>;
+}
+export interface CustomMPCv2SigningRound2GeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+        bitgoPublicGpgKey: string;
+        encryptedUserGpgPrvKey: string;
+        encryptedRound1Session: string;
+    }): Promise<{
+        signatureShareRound2: SignatureShareRecord;
+        encryptedRound2Session: string;
+    }>;
+}
+export interface CustomMPCv2SigningRound3GeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+        bitgoPublicGpgKey: string;
+        encryptedUserGpgPrvKey: string;
+        encryptedRound2Session: string;
+    }): Promise<{
+        signatureShareRound3: SignatureShareRecord;
+    }>;
+}
+export interface CustomEddsaMPCv2SigningRound1GeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+    }): Promise<{
+        signatureShareRound1: SignatureShareRecord;
+        encryptedRound1Session: string;
+        userGpgPubKey: string;
+        encryptedUserGpgPrvKey: string;
+    }>;
+}
+export interface CustomEddsaMPCv2SigningRound2GeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+        bitgoPublicGpgKey: string;
+        encryptedUserGpgPrvKey: string;
+        encryptedRound1Session: string;
+    }): Promise<{
+        signatureShareRound2: SignatureShareRecord;
+        encryptedRound2Session: string;
+    }>;
+}
+export interface CustomEddsaMPCv2SigningRound3GeneratingFunction {
+    (params: {
+        txRequest: TxRequest;
+        bitgoPublicGpgKey: string;
+        encryptedUserGpgPrvKey: string;
+        encryptedRound2Session: string;
+    }): Promise<{
+        signatureShareRound3: SignatureShareRecord;
+    }>;
+}
 export declare enum TokenType {
     ERC721 = "ERC721",
     ERC1155 = "ERC1155",
-    ERC20 = "ERC20"
+    ERC20 = "ERC20",
+    DIGITAL_ASSET = "Digital Asset"
 }
 export interface TokenTransferRecipientParams {
     tokenType: TokenType;
@@ -67,9 +272,46 @@ interface IntentOptionsBase {
     custodianTransactionId?: string;
     custodianMessageId?: string;
 }
+/**
+ * DeFi intent fields for ERC-4626 vault operations.
+ * Extended by PopulatedIntent so these land at the top level of the payload.
+ */
+export interface DefiIntentFields {
+    vaultId?: string;
+    amount?: {
+        value: string;
+        symbol: string;
+    } | string;
+    /** Vault share token amount for defi-withdraw intent (base units) */
+    shareTokenAmount?: {
+        value: string;
+        symbol: string;
+    } | string;
+    operationId?: string;
+}
+/** DeFi-specific intent parameters (input container for defiParams). */
+export interface DefiIntentParams {
+    vaultId: string;
+    amount: string;
+    operationId?: string;
+}
+/** ERC-7984 wrap / wrapApprove parameters (input container for wrapParams). */
+export interface WrapIntentParams {
+    tokenName: string;
+    amount: string;
+}
+/** ERC-7984 unwrap (unshield) parameters (input container for unwrapParams). */
+export interface UnwrapIntentParams {
+    tokenName: string;
+    amount: string;
+}
 export interface IntentOptionsForMessage extends IntentOptionsBase {
     messageRaw: string;
     messageEncoded?: string;
+    messageStandardType?: MessageStandardType;
+    signerAddress?: string;
+    /** Base64-encoded prepared transaction bytes required by Canton message signing. */
+    preparedTransaction?: string;
 }
 export interface IntentOptionsForTypedData extends IntentOptionsBase {
     typedDataRaw: string;
@@ -92,6 +334,77 @@ export interface PrebuildTransactionWithIntentOptions extends IntentOptionsBase
     lowFeeTxid?: string;
     custodianTransactionId?: string;
     receiveAddress?: string;
+    unspents?: string[];
+    /**
+     * MIST to redeem from the sender's address balance (SIP-58 / SUI address balances).
+     * When set, the PTB includes tx.withdrawal() + redeem_funds() before the transfer.
+     */
+    fundsInAddressBalance?: string;
+    /**
+     * The receive address from which funds will be withdrawn.
+     * This feature is supported only for specific coins, like ADA.
+     */
+    senderAddress?: string;
+    /**
+     * Custom Solana instructions for use with the customTx intent type.
+     * Each instruction should contain programId, keys, and data fields.
+     */
+    solInstructions?: SolInstruction[];
+    /**
+     * Deconstructed Versioned Transaction data for Solana customTx intent type.
+     * Contains compiled instructions, Address Lookup Tables, and static account keys.
+     */
+    solVersionedTransactionData?: SolVersionedTransactionData;
+    /**
+     * Custom transaction parameters for Aptos entry function calls.
+     * Used with the customTx intent type for Aptos smart contract interactions.
+     */
+    aptosCustomTransactionParams?: {
+        moduleName: string;
+        functionName: string;
+        typeArguments?: string[];
+        functionArguments?: any[];
+        abi?: any;
+    };
+    txRequestId?: string;
+    isTestTransaction?: boolean;
+    isWalletConnectTx?: boolean;
+    transferOfferId?: string;
+    /**
+     * Amount for intents that use a top-level amount instead of recipients (e.g. bridgeFunds).
+     */
+    amount?: {
+        value: string;
+        symbol: string;
+    };
+    /**
+     * TIP-20 token address to use for paying transaction fees (Tempo only).
+     */
+    feeToken?: string;
+    /** Canton-specific params for the cantonCommand intent. */
+    cantonCommandParams?: CantonCommandParams;
+    /** DeFi vault intent fields for defi-* and wrap-native / unwrap-native intents. */
+    defiParams?: DefiIntentParams;
+    /** ERC-7984 wrap / wrapApprove fields flattened onto the WP intent. */
+    wrapParams?: WrapIntentParams;
+    /** ERC-7984 unwrap (unshield) fields flattened onto the WP intent. */
+    unwrapParams?: UnwrapIntentParams;
+    /** Canton party ID of the end investor to onboard (cantonEndInvestorOnboardingOffer intent). */
+    endInvestorPartyId?: string;
+    /** Reason for rejecting the onboarding offer (cantonEndInvestorOnboardingReject intent). */
+    reason?: string;
+    /** DTCC operator party ID (cantonParticipantOnboardingRequest intent). */
+    operator?: string;
+    /** DTCC provider party ID (cantonParticipantOnboardingRequest intent). */
+    provider?: string;
+    /** DTCC compliance party ID (cantonParticipantOnboardingRequest intent). */
+    compliance?: string;
+    /** DTCC registrar party ID (cantonParticipantOnboardingRequest intent). */
+    registrar?: string;
+    /** DTCC client onboarder party ID (cantonParticipantOnboardingRequest intent). */
+    clientOnboarder?: string;
+    /** Optional ISO 8601 expiration timestamp (cantonParticipantOnboardingRequest intent). */
+    expirationIso?: string;
 }
 export interface IntentRecipient {
     address: {
@@ -115,41 +428,105 @@ export interface PopulatedIntentForMessageSigning extends PopulatedIntentBase {
     messageRaw: string;
     messageEncoded: string;
     custodianMessageId?: string;
+    messageStandardType?: MessageStandardType;
+    signerAddress?: string;
+    /** Base64-encoded prepared transaction bytes required by Canton message signing. */
+    preparedTransaction?: string;
 }
 export interface PopulatedIntentForTypedDataSigning extends PopulatedIntentBase {
     messageRaw: string;
     messageEncoded: string;
     custodianMessageId?: string;
 }
-export interface PopulatedIntent extends PopulatedIntentBase {
+export interface PopulatedIntent extends PopulatedIntentBase, DefiIntentFields {
+    stakingRequestId?: string;
     recipients?: IntentRecipient[];
     nonce?: string;
     token?: string;
     enableTokens?: TokenEnablement[];
+    unspents?: string[];
+    fundsInAddressBalance?: string;
+    /**
+     * The receive address from which funds will be withdrawn.
+     * This feature is supported only for specific coins, like ADA.
+     */
+    senderAddress?: string;
     selfSend?: boolean;
     feeOptions?: FeeOption | EIP1559FeeOptions;
+    /**
+     * TIP-20 token address to use for paying transaction fees (Tempo only).
+     * This is placed at the intent level, not nested in feeOptions.
+     */
+    feeToken?: string;
     hopParams?: HopParams;
     txid?: string;
     receiveAddress?: string;
     custodianTransactionId?: string;
     custodianMessageId?: string;
+    tokenName?: string;
+    /**
+     * Custom Solana instructions for use with the customTx intent type.
+     * Each instruction should contain programId, keys, and data fields.
+     */
+    solInstructions?: SolInstruction[];
+    /**
+     * Deconstructed Versioned Transaction data for Solana customTx intent type.
+     * Contains compiled instructions, Address Lookup Tables, and static account keys.
+     */
+    solVersionedTransactionData?: SolVersionedTransactionData;
+    /**
+     * Custom Aptos transaction for use with the customTx intent type.
+     */
+    aptosCustomTransactionParams?: aptosCustomTransactionParams;
+    txRequestId?: string;
+    isTestTransaction?: boolean;
+    isWalletConnectTx?: boolean;
+    transferOfferId?: string;
+    /**
+     * Amount for intents that use a top-level amount instead of recipients (e.g. bridgeFunds).
+     */
+    amount?: {
+        value: string;
+        symbol: string;
+    } | string;
+    /** Canton-specific params serialized into the cantonCommand intent payload. */
+    cantonCommandParams?: CantonCommandParams;
+    /** Canton party ID of the end investor to onboard (cantonEndInvestorOnboardingOffer intent). */
+    endInvestorPartyId?: string;
+    /** Reason for rejecting the onboarding offer (cantonEndInvestorOnboardingReject intent). */
+    reason?: string;
+    /** DTCC operator party ID (cantonParticipantOnboardingRequest intent). */
+    operator?: string;
+    /** DTCC provider party ID (cantonParticipantOnboardingRequest intent). */
+    provider?: string;
+    /** DTCC compliance party ID (cantonParticipantOnboardingRequest intent). */
+    compliance?: string;
+    /** DTCC registrar party ID (cantonParticipantOnboardingRequest intent). */
+    registrar?: string;
+    /** DTCC client onboarder party ID (cantonParticipantOnboardingRequest intent). */
+    clientOnboarder?: string;
+    /** Optional ISO 8601 expiration timestamp (cantonParticipantOnboardingRequest intent). */
+    expirationIso?: string;
 }
-export declare type TxRequestState = 'pendingApproval' | 'canceled' | 'rejected' | 'initialized' | 'pendingDelivery' | 'delivered' | 'pendingUserSignature' | 'signed';
-export declare type TransactionState = 'initialized' | 'pendingSignature' | 'signed' | 'held' | 'delivered' | 'invalidSignature' | 'rejected';
-export declare type SignableTransaction = {
+export type TxRequestState = 'pendingCommitment' | 'pendingApproval' | 'canceled' | 'rejected' | 'initialized' | 'pendingDelivery' | 'delivered' | 'pendingUserSignature' | 'signed';
+export type TransactionState = 'initialized' | 'pendingCommitment' | 'pendingSignature' | 'signed' | 'held' | 'delivered' | 'invalidSignature' | 'rejected';
+export type SignableTransaction = {
     serializedTxHex: string;
     signableHex: string;
 };
-export declare type UnsignedTransactionTss = SignableTransaction & {
+export interface ReplayProtectionOptions {
+    chain: string | number;
+    hardfork: string;
+}
+export type UnsignedTransactionTss = SignableTransaction & {
     derivationPath: string;
-    feeInfo?: {
-        fee: number;
-        feeString: string;
-    };
+    feeInfo?: Required<PrebuildTransactionFeeInfo>;
     coinSpecific?: Record<string, unknown>;
     parsedTx?: unknown;
+    eip1559?: EIP1559FeeOptions;
+    replayProtectionOptions?: ReplayProtectionOptions;
 };
-export declare type UnsignedMessageTss = {
+export type UnsignedMessageTss = {
     derivationPath: string;
     message: string;
 };
@@ -157,7 +534,13 @@ export declare enum RequestType {
     tx = 0,
     message = 1
 }
-export declare type TxRequest = {
+export type SignedTx = {
+    id: string;
+    tx: string;
+    publicKey?: string;
+    signature?: string;
+};
+export type TxRequest = {
     txRequestId: string;
     walletId: string;
     walletType: WalletType;
@@ -170,6 +553,7 @@ export declare type TxRequest = {
     pendingApprovalId?: string;
     policiesChecked: boolean;
     signatureShares?: SignatureShareRecord[];
+    commitmentShares?: CommitmentShareRecord[];
     pendingTxHashes?: string[];
     txHashes?: string[];
     unsignedMessages?: UnsignedMessageTss[];
@@ -178,49 +562,134 @@ export declare type TxRequest = {
         state: TransactionState;
         unsignedTx: UnsignedTransactionTss;
         signatureShares: SignatureShareRecord[];
+        signedTx?: SignedTx;
+        commitmentShares?: CommitmentShareRecord[];
     }[];
     messages?: {
         state: TransactionState;
         signatureShares: SignatureShareRecord[];
+        messageRaw: string;
+        messageEncoded?: string;
+        messageBroadcastable?: string;
+        messageStandardType?: MessageStandardType;
+        derivationPath: string;
         combineSigShare?: string;
         txHash?: string;
+        commitmentShares?: CommitmentShareRecord[];
     }[];
     apiVersion?: TxRequestVersion;
     latest: boolean;
 };
-export declare type CreateKeychainParamsBase = {
+export type CreateKeychainParamsBase = {
     userGpgKey: SerializedKeyPair<string>;
     bitgoKeychain: Keychain;
     passphrase?: string;
     enterprise?: string;
     originalPasscodeEncryptionCode?: string;
+    webauthnInfo?: WebauthnKeyEncryptionInfo;
+    encryptionVersion?: EncryptionVersion;
+    encryptionSession?: IEncryptionSession;
 };
-export declare type CreateBitGoKeychainParamsBase = Omit<CreateKeychainParamsBase, 'bitgoKeychain'>;
-export declare enum SignatureShareType {
-    USER = "user",
-    BACKUP = "backup",
-    BITGO = "bitgo"
-}
-export interface SignatureShareRecord {
+export type CreateBitGoKeychainParamsBase = Omit<CreateKeychainParamsBase, 'bitgoKeychain'>;
+/**
+ * Checks whether a ciphertext string is a v2 encryption envelope.
+ */
+export declare function isV2Envelope(ciphertext: string): boolean;
+export declare const SignatureShareType: {
+    readonly USER: "user";
+    readonly BACKUP: "backup";
+    readonly BITGO: "bitgo";
+};
+export type SignatureShareType = (typeof SignatureShareType)[keyof typeof SignatureShareType];
+interface ShareBaseRecord {
     from: SignatureShareType;
     to: SignatureShareType;
     share: string;
+}
+export interface SignatureShareRecord extends ShareBaseRecord {
     vssProof?: string;
     privateShareProof?: string;
     publicShare?: string;
 }
-export declare type TSSParams = {
+export declare const CommitmentType: {
+    readonly COMMITMENT: "commitment";
+    readonly DECOMMITMENT: "decommitment";
+};
+export type CommitmentType = (typeof CommitmentType)[keyof typeof CommitmentType];
+export interface CommitmentShareRecord extends ShareBaseRecord {
+    type: CommitmentType;
+}
+export interface ExchangeCommitmentResponse {
+    commitmentShare: CommitmentShareRecord;
+}
+export declare const EncryptedSignerShareType: {
+    readonly ENCRYPTED_SIGNER_SHARE: "encryptedSignerShare";
+    readonly ENCRYPTED_R_SHARE: "encryptedRShare";
+};
+export type EncryptedSignerShareType = (typeof EncryptedSignerShareType)[keyof typeof EncryptedSignerShareType];
+export interface EncryptedSignerShareRecord extends ShareBaseRecord {
+    type: EncryptedSignerShareType;
+}
+export type BitgoPubKeyType = 'nitro' | 'onprem';
+export type TSSParams = {
     txRequest: string | TxRequest;
-    prv: string;
     reqId: IRequestTracer;
     apiVersion?: ApiVersion;
-    hash?: Hash;
+    txParams?: TransactionParams;
 };
-export declare type TSSParamsForMessage = TSSParams & {
+export type TSSParamsForMessage = TSSParams & {
     messageRaw: string;
     messageEncoded?: string;
     bufferToSign: Buffer;
 };
+/** At least one recipient (when using `recipientSource: TssTxRecipientSource.Explicit`). */
+export type NonEmptyRecipientList = [ITransactionRecipient, ...ITransactionRecipient[]];
+/** txParams including a non-empty recipients list for strict signing verification typing. */
+export type TransactionParamsWithMandatoryRecipients = TransactionParams & {
+    recipients: NonEmptyRecipientList;
+};
+export declare const TssTxRecipientSource: {
+    /** Require txParams.recipients with at least one entry (enforced by TypeScript for this branch). */
+    readonly Explicit: "explicit";
+    /**
+     * Default: txParams may be omitted or partial; verification uses coin-specific rules
+     * (for example recipients from txRequest context).
+     */
+    readonly Resolved: "resolved";
+};
+export type TssTxRecipientSource = (typeof TssTxRecipientSource)[keyof typeof TssTxRecipientSource];
+export type TssSignTxExplicitRecipientParams = {
+    txRequest: string | TxRequest;
+    reqId: IRequestTracer;
+    apiVersion?: ApiVersion;
+    recipientSource: typeof TssTxRecipientSource.Explicit;
+    txParams: TransactionParamsWithMandatoryRecipients;
+};
+export type TssSignTxResolvedRecipientParams = {
+    txRequest: string | TxRequest;
+    reqId: IRequestTracer;
+    apiVersion?: ApiVersion;
+    recipientSource?: typeof TssTxRecipientSource.Resolved;
+    txParams?: TransactionParams;
+};
+/**
+ * Parameters for TSS transaction signing ({@link ITssUtils.signTxRequest}).
+ * Set {@link TssTxRecipientSource.Explicit} to require a non-empty txParams.recipients array at compile time.
+ */
+export type TssSignTxRequestParams = TssSignTxExplicitRecipientParams | TssSignTxResolvedRecipientParams;
+export type TssSignTxRequestParamsWithPrv = TssSignTxRequestParams & {
+    prv: string;
+    mpcv2PartyId?: 0 | 1;
+};
+/**
+ * @deprecated Use {@link TssSignTxRequestParamsWithPrv} instead. This alias exists for
+ * backwards compatibility and will be removed in a future major release.
+ */
+export type TSSParamsWithPrv = TssSignTxRequestParamsWithPrv;
+export type TSSParamsForMessageWithPrv = TSSParamsForMessage & {
+    prv: string;
+    mpcv2PartyId?: 0 | 1;
+};
 export interface BitgoHeldBackupKeyShare {
     commonKeychain?: string;
     id: string;
@@ -233,9 +702,101 @@ export interface BackupKeyShare {
 export interface BitgoGPGPublicKey {
     name: string;
     publicKey: string;
+    mpcv2PublicKey?: string;
+    eddsaMpcv2PublicKey?: string;
+    redpallasMpcv2PublicKey?: string;
     enterpriseId: string;
 }
-export declare type BackupGpgKey = SerializedKeyPair<string> | Key;
+export interface MPCTx {
+    serializedTx: string;
+    scanIndex?: number;
+    coin?: string;
+    signableHex?: string;
+    derivationPath?: string;
+    parsedTx?: ParsedTransaction;
+    feeInfo?: Required<PrebuildTransactionFeeInfo>;
+    coinSpecific?: {
+        firstValid?: number;
+        maxDuration?: number;
+        commonKeychain?: string;
+        lastScanIndex?: number;
+    };
+    recoveryAmount?: string;
+    signature?: string;
+}
+export interface MPCRecoveryOptions {
+    userKey?: string;
+    backupKey?: string;
+    bitgoKey: string;
+    recoveryDestination: string;
+    walletPassphrase?: string;
+    seed?: string;
+    index?: number;
+    startingScanIndex?: number;
+    scan?: number;
+    tokenContractAddress?: string;
+    apiKey?: string;
+}
+export interface MPCConsolidationRecoveryOptions {
+    userKey?: string;
+    backupKey?: string;
+    bitgoKey: string;
+    walletPassphrase?: string;
+    startingScanIndex?: number;
+    endingScanIndex?: number;
+    seed?: string;
+    tokenContractAddress?: string;
+}
+export interface MPCSweepTxs {
+    txRequests: RecoveryTxRequest[];
+}
+export interface RecoveryTxRequest {
+    walletCoin: string;
+    transactions: MPCUnsignedTx[] | OvcTransaction[];
+}
+export interface MPCUnsignedTx {
+    unsignedTx: MPCTx;
+    signatureShares: [];
+}
+export interface MPCSweepRecoveryOptions {
+    signatureShares: SignatureShares[];
+}
+interface SignatureShares {
+    txRequest: RecoveryTxRequest;
+    tssVersion: string;
+    ovc: Ovc[];
+}
+interface OvcTransaction {
+    unsignedTx: MPCTx;
+    signatureShares: SignatureShareRecord[];
+    signatureShare: SignatureShare;
+}
+interface SignatureShare {
+    from: string;
+    to: string;
+    share: string;
+    publicShare: string;
+}
+interface Ovc {
+    eddsaSignature: Signature;
+    ecdsaSignature?: EcdsaSignature;
+    eddsaMpcv2Signature?: string;
+}
+export interface MPCTxs {
+    transactions: MPCTx[];
+    lastScanIndex?: number;
+}
+export interface OvcInput {
+    address: string;
+    value: number;
+    valueString: string;
+}
+export interface OvcOutput {
+    address: string;
+    valueString: string;
+    coinName?: string;
+}
+export type BackupGpgKey = SerializedKeyPair<string> | Key;
 /**
  * Common Interface for implementing signature scheme specific
  * util functions
@@ -251,32 +812,47 @@ export interface ITssUtils<KeyShare = EDDSA.KeyShare> {
         enterprise?: string;
         originalPasscodeEncryptionCode?: string;
         isThirdPartyBackup?: boolean;
+        encryptionVersion?: EncryptionVersion;
     }): Promise<KeychainsTriplet>;
-    signTxRequest(params: {
-        txRequest: string | TxRequest;
-        prv: string;
-        reqId: IRequestTracer;
-    }): Promise<TxRequest>;
+    signTxRequest(params: TssSignTxRequestParamsWithPrv): Promise<TxRequest>;
     signTxRequestForMessage(params: TSSParams): Promise<TxRequest>;
-    signUsingExternalSigner(txRequest: string | TxRequest, externalSignerRShareGenerator: CustomRShareGeneratingFunction, externalSignerGShareGenerator: CustomGShareGeneratingFunction): Promise<TxRequest>;
-    createRShareFromTxRequest(params: {
+    signEddsaTssUsingExternalSigner(txRequest: string | TxRequest, externalSignerCommitmentGenerator: CustomCommitmentGeneratingFunction, externalSignerRShareGenerator: CustomRShareGeneratingFunction, externalSignerGShareGenerator: CustomGShareGeneratingFunction): Promise<TxRequest>;
+    signEcdsaTssUsingExternalSigner(params: TSSParams | TSSParamsForMessage, requestType: RequestType, externalSignerPaillierModulusGetter: CustomPaillierModulusGetterFunction, externalSignerKShareGenerator: CustomKShareGeneratingFunction, externalSignerMuDeltaShareGenerator: CustomMuDeltaShareGeneratingFunction, externalSignerSShareGenerator: CustomSShareGeneratingFunction): Promise<TxRequest>;
+    createCommitmentShareFromTxRequest(params: {
         txRequest: TxRequest;
         prv: string;
+        walletPassphrase: string;
+        bitgoGpgPubKey: string;
+    }): Promise<{
+        userToBitgoCommitment: CommitmentShareRecord;
+        encryptedSignerShare: EncryptedSignerShareRecord;
+        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
+    }>;
+    createRShareFromTxRequest(params: {
+        txRequest: TxRequest;
+        walletPassphrase: string;
+        encryptedUserToBitgoRShare: EncryptedSignerShareRecord;
     }): Promise<{
         rShare: SignShare;
-        signingKeyYShare: YShare;
     }>;
     createGShareFromTxRequest(params: {
         txRequest: TxRequest;
         prv: string;
         bitgoToUserRShare: SignatureShareRecord;
         userToBitgoRShare: SignShare;
+        bitgoToUserCommitment: CommitmentShareRecord;
     }): Promise<GShare>;
     prebuildTxWithIntent(params: PrebuildTransactionWithIntentOptions, apiVersion?: TxRequestVersion, preview?: boolean): Promise<TxRequest>;
     deleteSignatureShares(txRequestId: string): Promise<SignatureShareRecord[]>;
     sendTxRequest(txRequestId: string): Promise<any>;
     recreateTxRequest(txRequestId: string, decryptedPrv: string, reqId: IRequestTracer): Promise<TxRequest>;
     getTxRequest(txRequestId: string): Promise<TxRequest>;
+    supportedTxRequestVersions(): TxRequestVersion[];
+    supportsVerifyKey(): boolean;
+    verifyKey(params: {
+        prv: string;
+        commonKeychain: string;
+    }): Promise<boolean>;
 }
 export {};
 //# sourceMappingURL=baseTypes.d.ts.map