@sidhujag/sysweb3-keyring 1.0.628 → 2.1.0

package/types/transactions/bip84-native-plan.d.ts

@@ -0,0 +1,83 @@
+import { Psbt, Network } from 'bitcoinjs-lib';
+import { Bip84PublicAccount, Bip84PublicNetwork } from '../public-bip84';
+export type Bip84NetworkBinding = Readonly<{
+    network: Bip84PublicNetwork;
+    endpoint: string;
+}>;
+export type Bip84Guard = Readonly<{
+    assertCurrent(): void;
+}>;
+export type Bip84NativePlan = Readonly<{
+    network: Bip84NetworkBinding;
+    account: Bip84PublicAccount;
+    inputs: readonly Readonly<{
+        txid: string;
+        vout: number;
+        branch: 0 | 1;
+        index: number;
+    }>[];
+    previousTransactions: readonly Readonly<{
+        txid: string;
+        rawTransaction: string;
+    }>[];
+    recipient: Readonly<{
+        address: string;
+        valueSatoshis: string;
+    }>;
+    change: Readonly<{
+        index: number;
+        valueSatoshis: string;
+    }> | null;
+    locktime: 0;
+    rbf: boolean;
+    feeLimits: Readonly<{
+        maxFeeSatoshis: string;
+        maxFeeRateSatPerVByte: string;
+    }>;
+}>;
+export type PreparedBip84NativeTransaction = Readonly<{
+    plan: Bip84NativePlan;
+    unsignedTransaction: string;
+    feeSatoshis: string;
+}>;
+export type Bip84NativeErrorCode = 'INVALID_REQUEST' | 'LIMIT_EXCEEDED' | 'UNSUPPORTED_NETWORK' | 'UNSUPPORTED_PARENT' | 'ACCOUNT_MISMATCH' | 'INPUT_MISMATCH' | 'FEE_LIMIT' | 'SIGNATURE_INVALID' | 'CANCELLED' | 'BUSY';
+export declare class Bip84NativeError extends Error {
+    readonly code: Bip84NativeErrorCode;
+    constructor(code: Bip84NativeErrorCode);
+}
+export declare const LIMITS: Readonly<{
+    inputs: 64;
+    parentBytes: 1000000;
+    totalParentBytes: 2000000;
+    parentComponents: 8192;
+    unsignedBytes: number;
+    signedBytes: number;
+    psbtBytes: number;
+    maxFee: 10000000n;
+    maxFeeRate: 1000n;
+}>;
+export type Bip84Profile = Readonly<{
+    chainId: number;
+    slip44: number;
+    currency: string;
+    maximumMoney: bigint;
+    addressNetwork: Network;
+}>;
+export declare const bip84Profile: (network: Bip84PublicNetwork) => Bip84Profile;
+export declare const fail: (code: Bip84NativeErrorCode) => never;
+export declare function record(value: unknown, fields: readonly string[]): Record<string, unknown>;
+export declare function index(value: unknown): number;
+export declare function snapshotBip84Network(value: unknown): Bip84NetworkBinding;
+export declare function snapshotBip84Guard(value: unknown): () => void;
+export type ValidatedBip84Plan = {
+    prepared: PreparedBip84NativeTransaction;
+    psbt: Psbt;
+    previousOutputs: readonly Readonly<{
+        script: Uint8Array;
+        value: bigint;
+    }>[];
+};
+/** Internal result includes owned mutable transaction data; public entry exports only prepare. */
+export declare function validateBip84NativePlan(value: unknown): ValidatedBip84Plan;
+/** Pure bounded preparation; returned data carries no signing authorization. */
+export declare function prepareBip84NativeTransaction(plan: Bip84NativePlan): PreparedBip84NativeTransaction;

package/types/transactions/ethereum.d.ts

@@ -43,7 +43,7 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
     get web3Provider(): CustomJsonRpcProvider;
     private ensureProvidersInitialized;
     private isUtxoNetwork;
-    signTypedData: (addr: string, typedData: TypedDataV1 | TypedMessage<any>, version: SignTypedDataVersion) => Promise<any>;
+    signTypedData: (addr: string, typedData: TypedDataV1 | TypedMessage<any>, version: SignTypedDataVersion) => Promise<string>;
     verifyUtxoAddress: (accountIndex: number, currency: string, slip44: number) => Promise<string | undefined>;
     verifyTypedSignature: (data: TypedDataV1 | TypedMessage<any>, signature: string, version: SignTypedDataVersion) => string;
     ethSign: (params: string[]) => Promise<string>;

package/types/transactions/prepared-bip84.d.ts

@@ -0,0 +1,27 @@
+import { BIP32Interface } from 'bip32';
+import { PreparedBip84NativeTransaction, ValidatedBip84Plan } from './bip84-native-plan';
+export type PreparedBip84SigningRequest = Readonly<{
+    account: Readonly<{
+        type: 'HDAccount';
+        index: number;
+        expectedAccountKey: string;
+    }>;
+    prepared: PreparedBip84NativeTransaction;
+}>;
+export type SignedBip84NativeTransaction = Readonly<{
+    rawTransaction: string;
+    txid: string;
+    wtxid: string;
+    unsignedTransaction: string;
+    feeSatoshis: string;
+    virtualSize: number;
+}>;
+/** Private host snapshot. A public prepared DTO never carries signing authority. */
+export declare function snapshotPreparedBip84Request(input: unknown): {
+    account: PreparedBip84SigningRequest['account'];
+    validated: ValidatedBip84Plan;
+};
+/** Only operation-owned nodes. No session/shared key objects may be supplied. */
+export declare function clearBip84PrivateNodes(nodes: BIP32Interface[]): void;
+/** Internally owned PSBT only. No provider, generic SDK signer or partial result. */
+export declare function signValidatedBip84Plan(validated: ValidatedBip84Plan, accountNode: BIP32Interface, assertCurrent: () => void): SignedBip84NativeTransaction;

package/types/transactions/prepared-evm.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Fully specified type-0/type-2 transaction. Quantities are canonical decimal
+ * integer strings, nonce is at most MAX_SAFE_INTEGER, and gasLimit is uint64.
+ * Addresses must be nonzero hex addresses; valid casing is normalized. Data is
+ * even-length 0x hex, at most 16 KiB. Contract creation/access lists are omitted.
+ */
+export type PreparedEvmTransaction = Readonly<{
+    from: string;
+    to: string;
+    chainId: string;
+    nonce: string;
+    value: string;
+    gasLimit: string;
+    data: string;
+} & ({
+    type: 0;
+    gasPrice: string;
+} | {
+    type: 2;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+})>;
+export type PreparedSoftwareEvmSigningRequest = Readonly<{
+    account: Readonly<{
+        id: number;
+        type: 'HDAccount' | 'Imported';
+        expectedAddress: string;
+    }>;
+    network: Readonly<{
+        kind: 'ethereum';
+        chainId: string;
+        slip44: 60;
+        /** Exact configured endpoint binding; signing does not contact or authenticate it. */
+        url: string;
+    }>;
+    transaction: PreparedEvmTransaction;
+}>;
+export type PreparedEvmSigningOptions = Readonly<{
+    /** Host-owned consent/session/review expiry check. Must return undefined. */
+    assertCurrent(): void;
+}>;
+export type SignedPreparedEvmTransaction = Readonly<{
+    rawTransaction: string;
+    hash: string;
+    unsignedHash: string;
+    from: string;
+    /** Canonical signed fields, checked against the requested envelope. */
+    transaction: PreparedEvmTransaction;
+}>;
+export declare function snapshotPreparedEvmRequest(input: unknown): PreparedSoftwareEvmSigningRequest;
+export declare function preparedEvmGuard(input: unknown): () => void;
+/** Internal, network-free signing. The key never becomes part of the result. */
+export declare function signPreparedEvmEnvelope(transaction: PreparedEvmTransaction, privateKey: string): SignedPreparedEvmTransaction;

package/types/trezor/connect.d.ts

@@ -0,0 +1,42 @@
+import type { ConnectDynamicSettings, TrezorConnectPublicAPI } from '@trezor/connect-webextension';
+type Client = TrezorConnectPublicAPI<ConnectDynamicSettings>;
+declare const methods: readonly ["getFeatures", "getAccountInfo", "ethereumGetAddress", "ethereumGetPublicKey", "getPublicKey", "getAddress", "signTransaction", "ethereumSignTransaction", "signMessage", "ethereumSignMessage", "ethereumSignTypedData", "verifyMessage", "ethereumVerifyMessage"];
+type Method = (typeof methods)[number];
+type Compatible<T> = T extends {
+    success: false;
+} ? T & {
+    payload: {
+        error: string;
+        code?: string;
+    };
+} : T;
+type CompatibleCall<FunctionType> = FunctionType extends {
+    (...args: infer A): infer R;
+    (...args: infer B): infer S;
+    (...args: infer C): infer T;
+} ? {
+    (...args: A): Promise<Compatible<Awaited<R>>>;
+    (...args: B): Promise<Compatible<Awaited<S>>>;
+    (...args: C): Promise<Compatible<Awaited<T>>>;
+} : never;
+type Calls = {
+    [Name in Method]: CompatibleCall<Client[Name]>;
+};
+type ConnectionEvent = {
+    type: 'disconnected';
+} | {
+    type: 'model';
+    model: string;
+};
+export declare const subscribeTrezorEvents: (listener: (event: ConnectionEvent) => void) => (() => void);
+declare const TrezorConnect: Calls & {
+    init: Client['init'];
+    dispose: () => Promise<void>;
+};
+export declare const trezorResponseError: (response: {
+    payload?: {
+        error?: string;
+        code?: string;
+    };
+}, prefix?: string) => Error;
+export default TrezorConnect;

package/types/trezor/index.d.ts

@@ -1,7 +1,7 @@
 import { TypedMessage, SignTypedDataVersion, TypedDataV1 } from '@metamask/eth-sig-util';
-import { AccountInfo, EthereumTransaction, EthereumTransactionEIP1559 } from '@trezor/connect-webextension';
 import { Psbt } from 'bitcoinjs-lib';
 import { Buffer } from 'buffer';
+import type { AccountInfo, EthereumTransaction, EthereumTransactionEIP1559 } from '@trezor/connect-webextension';
 export interface TrezorControllerState {
     hdPath: string;
     paths: Record<string, number>;
@@ -19,7 +19,12 @@ export declare class TrezorKeyring {
     model?: string;
     private hardwareWalletManager;
     private initialized;
+    private lifecycleGeneration;
+    private unsubscribeTrezor?;
+    private readonly onTrezorConnected;
+    private readonly onTrezorDisconnected;
     constructor();
+    private observeTrezor;
     /**
      * Initialize Trezor script.
      */
@@ -51,7 +56,7 @@ export declare class TrezorKeyring {
      */
     getModel(): string | undefined;
     /**
-     * This removes the Trezor Connect iframe from the DOM
+     * This disposes the active Trezor Suite connection
      *
      * @returns void
      */
@@ -117,7 +122,20 @@ export declare class TrezorKeyring {
         tx: EthereumTransaction | EthereumTransactionEIP1559;
         coin: string;
         slip44: number;
-    }): Promise<any>;
+    }): Promise<import("@trezor/connect-webextension").OkWithDevice<{
+        authorizationList?: {
+            address: string;
+            chainId: number;
+            r: string;
+            s: string;
+            nonce: number;
+            yParity: number;
+        }[] | undefined;
+        r: string;
+        s: string;
+        v: string;
+        serializedTx: string;
+    }>>;
     /**
      * This sign message.
      *
@@ -146,7 +164,7 @@ export declare class TrezorKeyring {
         data: TypedMessage<any> | TypedDataV1;
         index: number;
         version: SignTypedDataVersion;
-    }): Promise<any>;
+    }): Promise<string>;
     /**
      * Verify UTXO address by displaying it on the Trezor device
      * @param accountIndex - The account index

package/types/trezor/witness.d.ts

@@ -0,0 +1,3 @@
+import { Buffer } from 'buffer';
+/** Canonical Bitcoin witness-vector encoding (CompactSize count and lengths). */
+export declare const serializeWitness: (witness: readonly Uint8Array[]) => Buffer;

package/types/utils/psbt-account-scope.d.ts

@@ -1,6 +1,7 @@
 import { INetwork } from '@sidhujag/sysweb3-network';
 import { Psbt } from 'bitcoinjs-lib';
 import { KeyringAccountType } from '../types';
+export declare const parsePsbtAccountXpub: (xpub: string) => import("bip32").BIP32Interface;
 export type PsbtAccountScope = {
     account: {
         address: string;