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

package/dist/src/bitgo/baseCoin/iBaseCoin.d.ts

@@ -1,19 +1,27 @@
-/// <reference types="node" />
+import { BaseTokenConfig, BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
 import BigNumber from 'bignumber.js';
 import { IRequestTracer } from '../../api';
 import { IEnterprises } from '../enterprise';
-import { Keychain, IKeychains } from '../keychain';
+import { ApiKeyShare, IKeychains, Keychain } from '../keychain';
 import { IMarkets } from '../market';
 import { IPendingApprovals } from '../pendingApproval';
 import { InitiateRecoveryOptions } from '../recovery';
-import { EcdsaUtils } from '../utils/tss/ecdsa';
-import EddsaUtils from '../utils/tss/eddsa';
-import { IWallet, IWallets, Wallet, WalletData } from '../wallet';
-import { IWebhooks } from '../webhook/iWebhooks';
-import { BaseTokenConfig } from '@bitgo-beta/statics';
+import { EcdsaMPCv2Utils, EcdsaUtils } from '../utils/tss/ecdsa';
+import EddsaUtils, { EddsaMPCv2Utils, PrebuildTransactionWithIntentOptions, TxRequest } from '../utils/tss/eddsa';
+import { RedpallasMPCv2Utils } from '../utils/tss/redpallas';
+import { CreateAddressFormat, CustomSigningFunction, IWallet, IWallets, Memo, Wallet, WalletData } from '../wallet';
+import { TokenEnablement, unifiedAddressPreference } from '@bitgo/public-types';
+import { Hash } from 'crypto';
 import { TransactionType } from '../../account-lib';
 import { IInscriptionBuilder } from '../inscriptionBuilder';
-import { Hash } from 'crypto';
+import { MessageStandardType, MPCTx, PopulatedIntent, TokenTransferRecipientParams, TokenType, Triple } from '../utils';
+import type { SignableTransaction } from '../utils/tss/baseTypes';
+import { IWebhooks } from '../webhook/iWebhooks';
+export declare const multisigTypes: {
+    readonly onchain: "onchain";
+    readonly tss: "tss";
+};
+export type MultisigType = keyof typeof multisigTypes;
 export interface Output extends ITransactionRecipient {
     address: string;
     coinName?: string;
@@ -27,7 +35,7 @@ export interface Output extends ITransactionRecipient {
     data?: string;
     change?: boolean;
 }
-export declare type Input = {
+export type Input = {
     derivationIndex?: number;
     value: number;
     address?: string;
@@ -35,7 +43,7 @@ export declare type Input = {
     chain?: number;
     index?: number;
 };
-export declare type UnsignedTransaction = {
+export type UnsignedTransaction = {
     serializedTxHex: string;
     signableHex: string;
     feeInfo?: {
@@ -57,23 +65,58 @@ export interface ITransactionRecipient {
     address: string;
     amount: string | number;
     tokenName?: string;
+    tokenAddress?: string;
+    programId?: string;
     memo?: string;
+    data?: string;
+}
+/**
+ * Represents a token enablement (e.g., creation of an associated token account)
+ */
+export interface ITokenEnablement {
+    address: string;
+    tokenName: string;
+    tokenAddress?: string;
 }
 export interface ITransactionFee<TAmount = string> {
     fee: TAmount;
     feeRate?: number;
     size?: number;
 }
+export type AuditKeyParams = {
+    prv?: string;
+    encryptedPrv?: string;
+    walletPassphrase?: string;
+} & ({
+    prv: string;
+} | {
+    encryptedPrv: string;
+    walletPassphrase: string;
+}) & ({
+    multiSigType: 'tss';
+    publicKey: string;
+} | {
+    multiSigType?: 'onchain';
+    publicKey?: string;
+});
+export type AuditDecryptedKeyParams = Omit<AuditKeyParams, 'encryptedPrv' | 'walletPassphrase'> & {
+    prv: string;
+};
 export interface ITransactionExplanation<TFee = any, TAmount = any> {
-    displayOrder: string[];
+    /** @deprecated */
+    displayOrder?: string[];
     id: string;
+    /** NOTE: External recipients */
     outputs: ITransactionRecipient[];
+    /** NOTE: External amount */
     outputAmount: TAmount;
     changeOutputs: ITransactionRecipient[];
     changeAmount: TAmount;
     fee: TFee;
     proxy?: string;
     producers?: string[];
+    /** NOTE: Tokens being enabled for the wallet */
+    tokenEnablements?: ITokenEnablement[];
 }
 export interface KeyPair {
     pub?: string;
@@ -85,24 +128,132 @@ export interface IBlsKeyPair extends KeyPair {
     seed?: string;
 }
 export interface VerifyAddressOptions {
+    format?: CreateAddressFormat;
     address: string;
     addressType?: string;
     keychains?: {
         pub: string;
-        commonKeychain?: string;
     }[];
     error?: string;
     coinSpecific?: AddressCoinSpecific;
     impliedForwarderVersion?: number;
+    /**
+     * Optional seed value from user keychain's derivedFromParentWithSeed field.
+     * For SMC (Self-Managed Custodial) TSS wallets, this is used to compute the derivation prefix.
+     */
+    derivedFromParentWithSeed?: string;
+    /**
+     * Identifies the MPC signing protocol version of the wallet (e.g. 'MPCv2').
+     * Used to distinguish between MPCv1 and MPCv2 wallets.
+     */
+    multisigTypeVersion?: 'MPCv2';
 }
-export interface TssVerifyAddressOptions extends VerifyAddressOptions {
-    chain: string;
-    index: string;
+/**
+ * Options for verifying if an address belongs to a TSS/MPC wallet.
+ * Used for EdDSA-based MPC coins (SOL, DOT, SUI, TON, IOTA, NEAR, etc.)
+ * to cryptographically verify address derivation without trusting the platform.
+ */
+export interface TssVerifyAddressOptions {
+    /** The address to verify */
+    address: string;
+    /**
+     * Keychains containing the commonKeychain for HD derivation.
+     * For MPC wallets, the commonKeychain (combined public key from MPC key generation)
+     * should be identical across all keychains (user, backup, bitgo).
+     */
+    keychains: Pick<Keychain, 'commonKeychain'>[];
+    /**
+     * Derivation index for the address.
+     * Used to derive child addresses from the root keychain via HD derivation path: m/{index}
+     * For SMC (Self-Managed Custodial) wallets, the path includes a prefix: m/{derivationPrefix}/{index}
+     */
+    index: number | string;
+    /**
+     * Optional seed value from user keychain's derivedFromParentWithSeed field.
+     * For SMC (Self-Managed Custodial) wallets, this is used to compute the derivation prefix.
+     * The derivation path becomes {computedPrefix}/{index} instead of m/{index}.
+     */
+    derivedFromParentWithSeed?: string;
+    /**
+     * Identifies the MPC signing protocol version of the wallet (e.g. 'MPCv2').
+     * Used to distinguish between MPCv1 and MPCv2 wallets.
+     */
+    multisigTypeVersion?: 'MPCv2';
+}
+export declare function isTssVerifyAddressOptions<T extends VerifyAddressOptions | TssVerifyAddressOptions>(params: T): params is T & TssVerifyAddressOptions;
+/**
+ * Options for locally deriving a wallet receive address from a derivation path.
+ *
+ * Unlike {@link VerifyAddressOptions}, which checks a candidate address, these options are
+ * used to *produce* the address offline from public key material only:
+ * - the user/backup/bitgo xpub triple (`pub`) for BIP32 multisig coins, or
+ * - the `commonKeychain` for TSS/MPC coins.
+ *
+ * No private keys and no network access are required.
+ */
+export interface DeriveAddressOptions extends Pick<VerifyAddressOptions, 'format' | 'derivedFromParentWithSeed' | 'multisigTypeVersion'> {
+    /**
+     * Derivation index for the address.
+     * For BIP32 multisig coins this is combined with `chain`; for TSS/MPC coins the
+     * derivation path is `m/{index}` (or `{prefix}/{index}` for SMC wallets).
+     */
+    index: number;
+    /** Derivation chain code (UTXO script-type / external-vs-internal selector). */
+    chain?: number;
+    /**
+     * Public key material for derivation. Each keychain must carry at least one of:
+     * - BIP32 multisig (UTXO, legacy EVM): the user/backup/bitgo xpub triple via `pub`.
+     * - TSS/MPC (SOL, EVM MPC, etc.): the `commonKeychain` (identical across keychains).
+     *
+     * Modelled as a union so a keychain with neither field is a type error. A keychain may
+     * still carry both fields (TSS keychains commonly expose `pub` alongside `commonKeychain`).
+     */
+    keychains?: ({
+        pub: string;
+    } | {
+        commonKeychain: string;
+    })[];
+    /** Wallet version, used to disambiguate derivation strategy for some coin families. */
+    walletVersion?: number;
+    /**
+     * Token name (e.g. `sol:usdc`, `tsol:usdt`) to derive a token deposit address instead of the
+     * native receive address. For Solana this resolves to the SPL mint and returns the wallet's
+     * Associated Token Account (ATA) for that mint. Ignored by coins/tokens that reuse the native
+     * address (e.g. ERC-20 on EVM).
+     */
+    tokenName?: string;
+    /**
+     * Wallet base address (the wallet contract address for EVM wallets). Required to derive
+     * per-index forwarder (CREATE2) receive addresses for legacy multisig EVM wallets.
+     */
+    baseAddress?: string;
+    /**
+     * Coin-specific derivation inputs. For EVM legacy forwarder wallets this carries
+     * `forwarderVersion` (1/2/4) and, for v4, `feeAddress`.
+     */
+    coinSpecific?: AddressCoinSpecific;
+}
+/**
+ * Result of locally deriving a wallet receive address.
+ *
+ * Extends {@link AddressVerificationData} (`chain`, `index`, `coinSpecific`) and adds the
+ * resolved `address` and the HD `derivationPath` actually used.
+ */
+export interface DeriveAddressResult extends AddressVerificationData {
+    /** The derived address. */
+    address: string;
+    /** The derivation index used. */
+    index: number;
+    /** The HD derivation path actually used to derive the address. */
+    derivationPath?: string;
 }
 export interface TransactionParams {
     recipients?: ITransactionRecipient[];
     walletPassphrase?: string;
     type?: string;
+    memo?: Memo;
+    enableTokens?: TokenEnablement[];
+    stakingRequestId?: string;
 }
 export interface AddressVerificationData {
     coinSpecific?: AddressCoinSpecific;
@@ -121,19 +272,21 @@ export interface VerificationOptions {
     };
     allowPaygoOutput?: boolean;
     considerMigratedFromAddressInternal?: boolean;
+    verifyTokenEnablement?: boolean;
+    consolidationToBaseAddress?: boolean;
 }
 export interface VerifyTransactionOptions {
     txPrebuild: TransactionPrebuild;
     txParams: TransactionParams;
-    wallet: Wallet;
+    wallet: IWallet;
     verification?: VerificationOptions;
     reqId?: IRequestTracer;
     walletType?: 'onchain' | 'tss';
 }
 export interface SupplementGenerateWalletOptions {
     label: string;
-    m: number;
-    n: number;
+    m?: number;
+    n?: number;
     enterprise?: string;
     disableTransactionNotifications?: boolean;
     gasPrice?: number | string;
@@ -142,8 +295,7 @@ export interface SupplementGenerateWalletOptions {
         maxPriorityFeePerGas?: number | string;
     };
     walletVersion?: number;
-    keys: string[];
-    isCold: boolean;
+    keys?: string[];
     keySignatures?: {
         backup: string;
         bitgo: string;
@@ -151,6 +303,13 @@ export interface SupplementGenerateWalletOptions {
     rootPrivateKey?: string;
     disableKRSEmail?: boolean;
     multisigType?: 'tss' | 'onchain' | 'blsdkg';
+    type: 'hot' | 'cold' | 'custodial' | 'advanced' | 'trading';
+    subType?: 'lightningCustody' | 'lightningSelfCustody' | 'onPrem';
+    coinSpecific?: {
+        [coinName: string]: unknown;
+    };
+    evmKeyRingReferenceWalletId?: string;
+    lightningProvider?: 'voltage' | 'amboss';
 }
 export interface FeeEstimateOptions {
     numBlocks?: number;
@@ -160,13 +319,19 @@ export interface FeeEstimateOptions {
     amount?: string;
     type?: keyof typeof TransactionType;
 }
+/** How a Zcash Unified Address recipient should be resolved. */
+export type UnifiedRecipientPreference = unifiedAddressPreference;
 export interface ExtraPrebuildParamsOptions {
+    /**
+     * how to resolve a Unified Address recipient (`'shielded'` or `'transparent'`).
+     */
+    unifiedRecipientPreference?: UnifiedRecipientPreference;
     [index: string]: unknown;
 }
 export interface PresignTransactionOptions {
     txPrebuild?: TransactionPrebuild;
     walletData: WalletData;
-    tssUtils: EcdsaUtils | EddsaUtils | undefined;
+    tssUtils: EcdsaUtils | EcdsaMPCv2Utils | EddsaUtils | EddsaMPCv2Utils | RedpallasMPCv2Utils | undefined;
     [index: string]: unknown;
 }
 export interface PrecreateBitGoOptions {
@@ -178,10 +343,15 @@ export interface VerifyRecoveryTransactionOptions {
 export interface ParseTransactionOptions {
     [index: string]: unknown;
 }
+/**
+ * This is only used for determining the PayGo fee of a transaction which is only relevant for UTXO coins.
+ * Some coins return various other fields here, but they are only used internally by the respective coins.
+ */
 export interface ParsedTransaction {
+    implicitExternalSpendAmount?: number | bigint;
     [index: string]: unknown;
 }
-export declare type UnsignedParsedTransaction = {
+export type UnsignedParsedTransaction = {
     inputs: Input[];
     minerFee: number | string;
     outputs: Output[];
@@ -200,9 +370,18 @@ export interface KeychainsTriplet {
     backupKeychain: Keychain;
     bitgoKeychain: Keychain;
 }
+export interface LightningKeychainsTriplet {
+    userKeychain: Keychain;
+    userAuthKeychain: Keychain;
+    nodeAuthKeychain: Keychain;
+}
+interface BuildParams {
+    preview?: boolean;
+    recipients?: ITransactionRecipient[];
+}
 interface BaseSignable {
     wallet?: IWallet;
-    buildParams?: any;
+    buildParams?: BuildParams & Partial<any>;
     consolidateId?: string;
     txRequestId?: string;
 }
@@ -211,9 +390,21 @@ export interface TransactionPrebuild extends BaseSignable {
     txHex?: string;
     txInfo?: unknown;
 }
+export interface XpubWithDerivationPath {
+    xpub: string;
+    derivedFromParentWithSeed?: string;
+}
+export interface ColdTransactionPrebuild {
+    pubs?: string[];
+    xpubsWithDerivationPath?: Partial<Record<ApiKeyShare['from'], XpubWithDerivationPath>>;
+}
 export interface Message extends BaseSignable {
     messageRaw: string;
     messageEncoded?: string;
+    messageStandardType?: MessageStandardType;
+    signerAddress?: string;
+    /** Base64-encoded prepared transaction bytes required by Canton message signing. */
+    preparedTransaction?: string;
 }
 export interface MessageTypeProperty {
     name: string;
@@ -269,12 +460,33 @@ export interface AddressCoinSpecific {
     baseAddress?: string;
     pendingChainInitialization?: boolean;
     forwarderVersion?: number;
+    /** Fee address for v4 EVM forwarders (used when deriving/verifying v4 forwarder addresses). */
+    feeAddress?: string;
+    /**
+     * Zcash shielded (Orchard/Ironwood) receiver data reported by wallet-platform. Present
+     * only for shielded addresses; see `assertShieldedWalletAddress`.
+     */
+    shielded?: {
+        /** Receiver type, e.g. 'ironwood'. */
+        type?: string;
+        /** 11-byte hex diversifier. */
+        diversifier?: string;
+        /** 32-byte hex `pk_d`. */
+        pkD?: string;
+        /** Wallet address index the diversifier was derived from. */
+        diversifierIndex?: number;
+    };
 }
 export interface FullySignedTransaction {
     txHex: string;
 }
 export interface HalfSignedUtxoTransaction {
     txHex: string;
+    /**
+     * PSBT-lite hex preserved from a pending approval's coinSpecific.
+     * Only present in the PA approval flow — not in regular sign/send flows.
+     */
+    txHexPsbt?: string;
 }
 export interface HalfSignedAccountTransaction {
     halfSigned?: {
@@ -290,6 +502,7 @@ export interface HalfSignedTransaction extends HalfSignedAccountTransaction {
         contractSequenceId?: number;
         sequenceId?: number;
         txHex?: never;
+        isBatch?: boolean;
     };
 }
 export interface SignedTransactionRequest {
@@ -303,13 +516,45 @@ export interface ValidMofNOptions {
     m?: number;
     n?: number;
 }
-export declare type SignedTransaction = HalfSignedAccountTransaction | HalfSignedUtxoTransaction | FullySignedTransaction | SignedTransactionRequest;
-export interface SignedMessage {
+export type SignedTransaction = HalfSignedAccountTransaction | HalfSignedUtxoTransaction | FullySignedTransaction | SignedTransactionRequest | TxRequest;
+/**
+ * Base fields shared by every message-sign result.
+ */
+export interface SignedMessageBase {
     coin?: string;
-    txHash: string;
     messageRaw: string;
+    messageEncoded?: string;
+    messageStandardType?: MessageStandardType;
     txRequestId: string;
 }
+/**
+ * The message-sign request was parked behind a pending approval by the
+ * message-signing policy; no signature was produced. The discriminator is the
+ * server-reported txRequest state ('pendingApproval') — never inferred from
+ * id presence. Surface the approval, then re-sign via
+ * signAndSendMessageTxRequest once it is resolved.
+ */
+export interface SignedMessagePendingApproval extends SignedMessageBase {
+    state: 'pendingApproval';
+    pendingApprovalId: string;
+}
+/**
+ * The message is signed and the request is terminal (wallet-platform
+ * transitions a message request pendingDelivery → delivered once all
+ * messages are signed; the txRequest-level 'signed' state is never used for
+ * message requests).
+ */
+export interface SignedMessageDelivered extends SignedMessageBase {
+    state: 'delivered';
+    txHash: string;
+    signature: string;
+}
+/**
+ * Discriminated on the wallet-platform txRequest state. BREAKING: consumers
+ * that previously read `txHash`/`signature` without narrowing must first
+ * check `state === 'delivered'`.
+ */
+export type SignedMessage = SignedMessagePendingApproval | SignedMessageDelivered;
 export interface RecoverWalletTokenOptions {
     tokenContractAddress: string;
     wallet: IWallet;
@@ -339,14 +584,51 @@ export interface RecoverTokenTransaction {
 export interface TokenEnablementConfig {
     requiresTokenEnablement: boolean;
     supportsMultipleTokenEnablements: boolean;
+    validateWallet?: (walletType: string) => void;
+    getEnableTokenType?: (tokenName: string) => string;
 }
 export interface MessagePrep {
     encodeMessage(message: string): string;
 }
-export declare type MPCAlgorithm = 'ecdsa' | 'eddsa';
+/**
+ * 'redpallas' is the MPC algorithm used for the Zcash Orchard shielded pool (RedPallas /
+ * "Ironwood"). Today it only supports DKG (key generation) via MPCv2 in this SDK - there is no
+ * online self-custody DSG (transaction signing) entrypoint yet, though the underlying
+ * signature-share primitives (`bitgo/tss/redpallas`) and the `sendSignatureShareV2` MPCv2
+ * request type exist as groundwork for a future custodial/cold (SMC/OVC) DSG signing flow.
+ * It is additive: existing coins never return it from `getMPCAlgorithm()` unless explicitly
+ * implemented to do so, so this does not change behavior for any existing ECDSA/EdDSA coin or
+ * for ZEC's existing transparent (secp256k1) multisig/TSS flows.
+ */
+export type MPCAlgorithm = 'ecdsa' | 'eddsa' | 'redpallas';
+export type NFTTransferOptions = {
+    tokenContractAddress: string;
+    recipientAddress: string;
+} & ({
+    type: 'ERC721' | TokenType.DIGITAL_ASSET;
+    tokenId: string;
+} | {
+    type: 'ERC1155';
+    entries: {
+        tokenId: string;
+        amount: number;
+    }[];
+});
+export type BuildNftTransferDataOptions = NFTTransferOptions & {
+    fromAddress: string;
+};
+export interface BaseBroadcastTransactionOptions {
+    serializedSignedTransaction: string;
+    transactions?: MPCTx[];
+}
+export interface BaseBroadcastTransactionResult {
+    txId?: string;
+    txIds?: string[];
+}
 export interface IBaseCoin {
     type: string;
     tokenConfig?: BaseTokenConfig;
+    getConfig(): Readonly<StaticsBaseCoin>;
     url(suffix: string): string;
     wallets(): IWallets;
     enterprises(): IEnterprises;
@@ -358,32 +640,62 @@ export interface IBaseCoin {
     getFamily(): string;
     getFullName(): string;
     valuelessTransferAllowed(): boolean;
+    checkRecipient(recipient: {
+        address: string;
+        amount: string | number;
+    }, options?: {
+        allowZeroAmount?: boolean;
+    }): void;
     sweepWithSendMany(): boolean;
     transactionDataAllowed(): boolean;
     allowsAccountConsolidations(): boolean;
+    supportsResourceDelegation(): boolean;
     getTokenEnablementConfig(): TokenEnablementConfig;
     supportsTss(): boolean;
+    supportsMultisig(): boolean;
+    getDefaultMultisigType(): MultisigType | undefined;
+    supportsDeriveKeyWithSeed(): boolean;
     isEVM(): boolean;
     supportsBlsDkg(): boolean;
+    prepareColdTransaction<T extends TransactionPrebuild>(txPrebuild: T, keychains: Triple<Keychain>): T & ColdTransactionPrebuild;
     getBaseFactor(): number | string;
     baseUnitsToBigUnits(baseUnits: string | number): string;
     bigUnitsToBaseUnits(bigUnits: string | number): string;
+    preprocessBuildParams(params: Record<string, any>): Record<string, any>;
     signMessage(key: {
         prv: string;
     }, message: string): Promise<Buffer>;
-    explainTransaction(options: Record<string, any>): Promise<ITransactionExplanation<any, string | number> | undefined>;
+    createKeySignatures(prv: string, backupKeychain: {
+        pub: string;
+    }, bitgoKeychain: {
+        pub: string;
+    }): Promise<{
+        backup: string;
+        bitgo: string;
+    }>;
+    explainTransaction(options: Record<string, any>, wallet?: IWallet): Promise<ITransactionExplanation<any, string | number> | undefined>;
     verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
     verifyAddress(params: VerifyAddressOptions): Promise<boolean>;
-    isWalletAddress(params: VerifyAddressOptions): Promise<boolean>;
+    isWalletAddress(params: VerifyAddressOptions | TssVerifyAddressOptions, wallet?: IWallet): Promise<boolean>;
+    deriveAddress(params: DeriveAddressOptions): Promise<DeriveAddressResult>;
     canonicalAddress(address: string, format: unknown): string;
     supportsBlockTarget(): boolean;
     supportsLightning(): boolean;
     supportsMessageSigning(): boolean;
     supportsSigningTypedData(): boolean;
+    /**
+     * Coin-specific validation of a message payload before it is forwarded for signing.
+     * Implementations must throw when the message is not signable for this coin.
+     */
+    validateSignableMessage?(message: Pick<Message, 'messageRaw' | 'messageStandardType' | 'signerAddress'>): void;
     supplementGenerateWallet(walletParams: SupplementGenerateWalletOptions, keychains: KeychainsTriplet): Promise<any>;
     getExtraPrebuildParams(buildParams: ExtraPrebuildParamsOptions): Promise<Record<string, unknown>>;
     postProcessPrebuild(prebuildResponse: TransactionPrebuild): Promise<TransactionPrebuild>;
     presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions>;
+    signWithCustomSigningFunction?(customSigningFunction: CustomSigningFunction, signTransactionParams: {
+        txPrebuild: TransactionPrebuild;
+        pubs: string[];
+    }): Promise<SignedTransaction>;
     newWalletObject(walletParams: any): IWallet;
     feeEstimate(params: FeeEstimateOptions): Promise<any>;
     deriveKeyWithSeed(params: DeriveKeyWithSeedOptions): {
@@ -395,6 +707,7 @@ export interface IBaseCoin {
     initiateRecovery(params: InitiateRecoveryOptions): never;
     parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
     generateKeyPair(seed?: Buffer): KeyPair;
+    generateRootKeyPair(seed?: Buffer): KeyPair;
     isValidPub(pub: string): boolean;
     isValidMofNSetup(params: ValidMofNOptions): boolean;
     isValidAddress(address: string): boolean;
@@ -403,7 +716,31 @@ export interface IBaseCoin {
     getMPCAlgorithm(): MPCAlgorithm;
     recoverToken(params: RecoverWalletTokenOptions): Promise<RecoverTokenTransaction>;
     getInscriptionBuilder(wallet: Wallet): IInscriptionBuilder;
+    /**
+     * Build the call data for transferring a NFT(s).
+     * @param params Options specifying the token contract, token recipient & the token(s) to be transferred
+     * @return the hex string for the contract call.
+     */
+    buildNftTransferData(params: BuildNftTransferDataOptions): string | TokenTransferRecipientParams;
     getHashFunction(): Hash;
+    /**
+     * Returns true when signableHex is already the final signing hash for MPC signing
+     * (e.g. SHA-256 for Avalanche atomic cross-chain txs). Only implemented by coins
+     * that produce pre-hashed signable material.
+     */
+    isSignablePreHashed?(unsignedTx: SignableTransaction): boolean;
+    broadcastTransaction(params: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult>;
+    setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void;
+    /**
+     * Audit a key to determine if it is valid for the coin.
+     * @param {Object} params - The parameters for the audit
+     * @param {string} params.publicKey  - The public portion of the key
+     * @param {string} params.encryptedPrv - The encrypted private key
+     * @param {string} params.walletPassphrase - The passphrase to decrypt the private key
+     * @param {string} params.multiSigType - The type of multisig (e.g. 'onchain' or 'tss')
+     */
+    assertIsValidKey(params: AuditKeyParams): Promise<void>;
+    requiresWalletInitializationTransaction(): boolean;
 }
 export {};
 //# sourceMappingURL=iBaseCoin.d.ts.map