@trezor/connect 9.0.0-beta.1

package/lib/types/api/on.d.ts

@@ -0,0 +1,14 @@
+import type { BlockchainEvent, BlockchainEventListenerFn } from '../../events/blockchain';
+import type { DeviceEvent, DeviceEventListenerFn } from '../../events/device';
+import type { TransportEvent, TransportEventListenerFn } from '../../events/transport';
+import type { UiEvent, UiEventListenerFn, ProgressEventListenerFn } from '../../events/ui-request';
+import type { UnionToIntersection } from '../utils';
+declare type DetailedEvent<Event> = Event extends {
+    type: string;
+} ? Event extends {
+    payload: any;
+} ? (type: Event['type'], cb: (event: Event['payload']) => any) => void : (type: Event['type'], cb: () => any) => void : never;
+declare type EventsUnion = BlockchainEventListenerFn | DetailedEvent<BlockchainEvent> | DeviceEventListenerFn | DetailedEvent<DeviceEvent> | TransportEventListenerFn | DetailedEvent<TransportEvent> | UiEventListenerFn | DetailedEvent<UiEvent> | ProgressEventListenerFn;
+export declare const on: UnionToIntersection<EventsUnion>;
+export {};
+//# sourceMappingURL=on.d.ts.map

package/lib/types/api/on.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=on.js.map

package/lib/types/api/pushTransaction.d.ts

@@ -0,0 +1,10 @@
+import type { Params, Response } from '../params';
+export declare type PushTransaction = {
+    tx: string;
+    coin: string;
+};
+export interface PushedTransaction {
+    txid: string;
+}
+export declare function pushTransaction(params: Params<PushTransaction>): Response<PushedTransaction>;
+//# sourceMappingURL=pushTransaction.d.ts.map

package/lib/types/api/pushTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=pushTransaction.js.map

package/lib/types/api/rebootToBootloader.d.ts

@@ -0,0 +1,4 @@
+import type { PROTO } from '../../constants';
+import type { CommonParams, Response } from '../params';
+export declare function rebootToBootloader(params?: CommonParams): Response<PROTO.Success>;
+//# sourceMappingURL=rebootToBootloader.d.ts.map

package/lib/types/api/rebootToBootloader.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=rebootToBootloader.js.map

package/lib/types/api/recoveryDevice.d.ts

@@ -0,0 +1,7 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface RecoveryDevice extends Omit<PROTO.RecoveryDevice, 'word_count'> {
+    word_count?: 12 | 18 | 24;
+}
+export declare function recoveryDevice(params: Params<RecoveryDevice>): Response<PROTO.Success>;
+//# sourceMappingURL=recoveryDevice.d.ts.map

package/lib/types/api/recoveryDevice.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=recoveryDevice.js.map

package/lib/types/api/removeAllListeners.d.ts

@@ -0,0 +1,3 @@
+import type { EventListenerType } from './off';
+export declare function removeAllListeners(type?: EventListenerType): void;
+//# sourceMappingURL=removeAllListeners.d.ts.map

package/lib/types/api/removeAllListeners.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=removeAllListeners.js.map

package/lib/types/api/renderWebUSBButton.d.ts

@@ -0,0 +1,2 @@
+export declare function renderWebUSBButton(className?: string): void;
+//# sourceMappingURL=renderWebUSBButton.d.ts.map

package/lib/types/api/renderWebUSBButton.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=renderWebUSBButton.js.map

package/lib/types/api/requestLogin.d.ts

@@ -0,0 +1,20 @@
+import type { Params, Response } from '../params';
+export interface LoginChallenge {
+    challengeHidden: string;
+    challengeVisual: string;
+    callback?: undefined;
+    asyncChallenge?: undefined;
+}
+export interface RequestLoginAsync {
+    callback: () => LoginChallenge;
+    asyncChallenge?: boolean;
+    challengeHidden?: undefined;
+    challengeVisual?: undefined;
+}
+export interface Login {
+    address: string;
+    publicKey: string;
+    signature: string;
+}
+export declare function requestLogin(params: Params<RequestLoginAsync | LoginChallenge>): Response<Login>;
+//# sourceMappingURL=requestLogin.d.ts.map

package/lib/types/api/requestLogin.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=requestLogin.js.map

package/lib/types/api/resetDevice.d.ts

@@ -0,0 +1,16 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface ResetDevice {
+    display_random?: boolean;
+    strength?: number;
+    passphrase_protection?: boolean;
+    pin_protection?: boolean;
+    language?: string;
+    label?: string;
+    u2f_counter?: number;
+    skip_backup?: boolean;
+    no_backup?: boolean;
+    backup_type?: 0 | 1;
+}
+export declare function resetDevice(params: Params<ResetDevice>): Response<PROTO.Success>;
+//# sourceMappingURL=resetDevice.d.ts.map

package/lib/types/api/resetDevice.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=resetDevice.js.map

package/lib/types/api/rippleGetAddress.d.ts

@@ -0,0 +1,4 @@
+import type { GetAddress, Address, Params, BundledParams, Response } from '../params';
+export declare function rippleGetAddress(params: Params<GetAddress>): Response<Address>;
+export declare function rippleGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
+//# sourceMappingURL=rippleGetAddress.d.ts.map

package/lib/types/api/rippleGetAddress.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=rippleGetAddress.js.map

package/lib/types/api/rippleSignTransaction.d.ts

@@ -0,0 +1,23 @@
+import type { Params, Response } from '../params';
+export interface RipplePayment {
+    amount: string;
+    destination: string;
+    destinationTag?: number;
+}
+export interface RippleTransaction {
+    fee: string;
+    flags?: number;
+    sequence: number;
+    maxLedgerVersion?: number;
+    payment: RipplePayment;
+}
+export interface RippleSignTransaction {
+    path: string | number[];
+    transaction: RippleTransaction;
+}
+export interface RippleSignedTx {
+    serializedTx: string;
+    signature: string;
+}
+export declare function rippleSignTransaction(params: Params<RippleSignTransaction>): Response<RippleSignedTx>;
+//# sourceMappingURL=rippleSignTransaction.d.ts.map

package/lib/types/api/rippleSignTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=rippleSignTransaction.js.map

package/lib/types/api/setProxy.d.ts

@@ -0,0 +1,9 @@
+import type { PROTO } from '../../constants';
+import type { CommonParams, Response } from '../params';
+import type { Proxy } from '../settings';
+export declare type SetProxy = {
+    proxy: Proxy;
+    useOnionLinks?: boolean;
+};
+export declare function setProxy(params: CommonParams & SetProxy): Response<PROTO.Success>;
+//# sourceMappingURL=setProxy.d.ts.map

package/lib/types/api/setProxy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=setProxy.js.map

package/lib/types/api/signMessage.d.ts

@@ -0,0 +1,11 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface SignMessage {
+    path: string | number[];
+    coin: string;
+    message: string;
+    hex?: boolean;
+    no_script_type?: boolean;
+}
+export declare function signMessage(params: Params<SignMessage>): Response<PROTO.MessageSignature>;
+//# sourceMappingURL=signMessage.d.ts.map

package/lib/types/api/signMessage.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=signMessage.js.map

package/lib/types/api/signTransaction.d.ts

@@ -0,0 +1,70 @@
+import type { AccountAddresses } from '@trezor/blockchain-link';
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export declare type RefTransaction = {
+    hash: string;
+    version: number;
+    inputs: PROTO.PrevInput[];
+    bin_outputs: PROTO.TxOutputBinType[];
+    outputs?: typeof undefined;
+    lock_time: number;
+    extra_data?: string;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+} | {
+    hash: string;
+    version: number;
+    inputs: PROTO.TxInput[];
+    bin_outputs?: typeof undefined;
+    outputs: PROTO.TxOutputType[];
+    lock_time: number;
+    extra_data?: string;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+};
+export interface TransactionOptions {
+    version?: number;
+    lock_time?: number;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+    decred_staking_ticket?: boolean;
+    amount_unit?: PROTO.AmountUnit;
+}
+export interface SignTransaction {
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+    paymentRequests?: PROTO.TxAckPaymentRequest[];
+    refTxs?: RefTransaction[];
+    account?: {
+        addresses: AccountAddresses;
+    };
+    coin: string;
+    locktime?: number;
+    timestamp?: number;
+    version?: number;
+    expiry?: number;
+    overwintered?: boolean;
+    versionGroupId?: number;
+    branchId?: number;
+    decredStakingTicket?: boolean;
+    push?: boolean;
+    preauthorized?: boolean;
+    amountUnit?: PROTO.AmountUnit;
+}
+export declare type SignedTransaction = {
+    signatures: string[];
+    serializedTx: string;
+    witnesses?: (string | undefined)[];
+    txid?: string;
+};
+export declare function signTransaction(params: Params<SignTransaction>): Response<SignedTransaction>;
+//# sourceMappingURL=signTransaction.d.ts.map

package/lib/types/api/signTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=signTransaction.js.map

package/lib/types/api/stellarGetAddress.d.ts

@@ -0,0 +1,4 @@
+import type { GetAddress, Address, Params, BundledParams, Response } from '../params';
+export declare function stellarGetAddress(params: Params<GetAddress>): Response<Address>;
+export declare function stellarGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
+//# sourceMappingURL=stellarGetAddress.d.ts.map

package/lib/types/api/stellarGetAddress.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=stellarGetAddress.js.map

package/lib/types/api/stellarSignTransaction.d.ts

@@ -0,0 +1,182 @@
+/// <reference types="node" />
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface StellarAsset {
+    type: PROTO.StellarAssetType;
+    code?: string;
+    issuer?: string;
+}
+export interface StellarCreateAccountOperation {
+    type: 'createAccount';
+    source?: string;
+    destination: string;
+    startingBalance: string;
+}
+export interface StellarPaymentOperation {
+    type: 'payment';
+    source?: string;
+    destination: string;
+    asset: StellarAsset;
+    amount: string;
+}
+export interface StellarPathPaymentStrictReceiveOperation {
+    type: 'pathPaymentStrictReceive';
+    source?: string;
+    sendAsset: StellarAsset;
+    sendMax: string;
+    destination: string;
+    destAsset: StellarAsset;
+    destAmount: string;
+    path?: StellarAsset[];
+}
+export interface StellarPathPaymentStrictSendOperation {
+    type: 'pathPaymentStrictSend';
+    source?: string;
+    sendAsset: StellarAsset;
+    sendAmount: string;
+    destination: string;
+    destAsset: StellarAsset;
+    destMin: string;
+    path?: StellarAsset[];
+}
+export interface StellarPassiveSellOfferOperation {
+    type: 'createPassiveSellOffer';
+    source?: string;
+    buying: StellarAsset;
+    selling: StellarAsset;
+    amount: string;
+    price: {
+        n: number;
+        d: number;
+    };
+}
+export interface StellarManageSellOfferOperation {
+    type: 'manageSellOffer';
+    source?: string;
+    buying: StellarAsset;
+    selling: StellarAsset;
+    amount: string;
+    offerId?: string;
+    price: {
+        n: number;
+        d: number;
+    };
+}
+export interface StellarManageBuyOfferOperation {
+    type: 'manageBuyOffer';
+    source?: string;
+    buying: StellarAsset;
+    selling: StellarAsset;
+    amount: string;
+    offerId?: string;
+    price: {
+        n: number;
+        d: number;
+    };
+}
+export interface StellarSetOptionsOperation {
+    type: 'setOptions';
+    source?: string;
+    signer?: {
+        type: PROTO.StellarSignerType;
+        key: string | Buffer;
+        weight?: number;
+    };
+    inflationDest?: string;
+    clearFlags?: number;
+    setFlags?: number;
+    masterWeight?: PROTO.UintType;
+    lowThreshold?: PROTO.UintType;
+    medThreshold?: PROTO.UintType;
+    highThreshold?: PROTO.UintType;
+    homeDomain?: string;
+}
+export interface StellarChangeTrustOperation {
+    type: 'changeTrust';
+    source?: string;
+    line: StellarAsset;
+    limit: string;
+}
+export interface StellarAllowTrustOperation {
+    type: 'allowTrust';
+    source?: string;
+    trustor: string;
+    assetCode: string;
+    assetType: PROTO.StellarAssetType;
+    authorize?: boolean | typeof undefined;
+}
+export interface StellarAccountMergeOperation {
+    type: 'accountMerge';
+    source?: string;
+    destination: string;
+}
+export interface StellarManageDataOperation {
+    type: 'manageData';
+    source?: string;
+    name: string;
+    value?: string | Buffer;
+}
+export interface StellarBumpSequenceOperation {
+    type: 'bumpSequence';
+    source?: string;
+    bumpTo: string;
+}
+export interface StellarInflationOperation {
+    type: 'inflation';
+    source?: string;
+}
+export declare type StellarOperation = StellarCreateAccountOperation | StellarPaymentOperation | StellarPathPaymentStrictReceiveOperation | StellarPathPaymentStrictSendOperation | StellarPassiveSellOfferOperation | StellarManageSellOfferOperation | StellarManageBuyOfferOperation | StellarSetOptionsOperation | StellarChangeTrustOperation | StellarAllowTrustOperation | StellarAccountMergeOperation | StellarInflationOperation | StellarManageDataOperation | StellarBumpSequenceOperation;
+export interface StellarTransaction {
+    source: string;
+    fee: number;
+    sequence: PROTO.UintType;
+    timebounds?: {
+        minTime: number;
+        maxTime: number;
+    };
+    memo?: {
+        type: PROTO.StellarMemoType;
+        id?: string;
+        text?: string;
+        hash?: string | Buffer;
+    };
+    operations: StellarOperation[];
+}
+export interface StellarSignTransaction {
+    path: string | number[];
+    networkPassphrase: string;
+    transaction: StellarTransaction;
+}
+export interface StellarSignedTx {
+    publicKey: string;
+    signature: string;
+}
+export declare type StellarOperationMessage = ({
+    type: 'StellarCreateAccountOp';
+} & PROTO.StellarCreateAccountOp) | ({
+    type: 'StellarPaymentOp';
+} & PROTO.StellarPaymentOp) | ({
+    type: 'StellarPathPaymentStrictReceiveOp';
+} & PROTO.StellarPathPaymentStrictReceiveOp) | ({
+    type: 'StellarPathPaymentStrictSendOp';
+} & PROTO.StellarPathPaymentStrictSendOp) | ({
+    type: 'StellarManageSellOfferOp';
+} & PROTO.StellarManageSellOfferOp) | ({
+    type: 'StellarManageBuyOfferOp';
+} & PROTO.StellarManageBuyOfferOp) | ({
+    type: 'StellarCreatePassiveSellOfferOp';
+} & PROTO.StellarCreatePassiveSellOfferOp) | ({
+    type: 'StellarSetOptionsOp';
+} & PROTO.StellarSetOptionsOp) | ({
+    type: 'StellarChangeTrustOp';
+} & PROTO.StellarChangeTrustOp) | ({
+    type: 'StellarAllowTrustOp';
+} & PROTO.StellarAllowTrustOp) | ({
+    type: 'StellarAccountMergeOp';
+} & PROTO.StellarAccountMergeOp) | ({
+    type: 'StellarManageDataOp';
+} & PROTO.StellarManageDataOp) | ({
+    type: 'StellarBumpSequenceOp';
+} & PROTO.StellarBumpSequenceOp);
+export declare function stellarSignTransaction(params: Params<StellarSignTransaction>): Response<StellarSignedTx>;
+//# sourceMappingURL=stellarSignTransaction.d.ts.map

package/lib/types/api/stellarSignTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=stellarSignTransaction.js.map

package/lib/types/api/tezosGetAddress.d.ts

@@ -0,0 +1,4 @@
+import type { GetAddress, Address, Params, BundledParams, Response } from '../params';
+export declare function tezosGetAddress(params: Params<GetAddress>): Response<Address>;
+export declare function tezosGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
+//# sourceMappingURL=tezosGetAddress.d.ts.map

package/lib/types/api/tezosGetAddress.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tezosGetAddress.js.map

package/lib/types/api/tezosGetPublicKey.d.ts

@@ -0,0 +1,4 @@
+import type { GetPublicKey, PublicKey, Params, BundledParams, Response } from '../params';
+export declare function tezosGetPublicKey(params: Params<GetPublicKey>): Response<PublicKey>;
+export declare function tezosGetPublicKey(params: BundledParams<GetPublicKey>): Response<PublicKey[]>;
+//# sourceMappingURL=tezosGetPublicKey.d.ts.map

package/lib/types/api/tezosGetPublicKey.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tezosGetPublicKey.js.map

package/lib/types/api/tezosSignTransaction.d.ts

@@ -0,0 +1,61 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface TezosRevealOperation {
+    source: string;
+    fee: number;
+    counter: number;
+    gas_limit: number;
+    storage_limit: number;
+    public_key: string;
+}
+export interface TezosManagerTransfer {
+    destination: string;
+    amount: number;
+}
+export interface TezosParametersManager {
+    set_delegate?: string;
+    cancel_delegate?: boolean;
+    transfer?: TezosManagerTransfer;
+}
+export interface TezosTransactionOperation {
+    source: string;
+    destination: string;
+    amount: number;
+    counter: number;
+    fee: number;
+    gas_limit: number;
+    storage_limit: number;
+    parameters?: number[];
+    parameters_manager?: TezosParametersManager;
+}
+export interface TezosOriginationOperation {
+    source: string;
+    balance: number;
+    delegate?: string;
+    script: string | number[];
+    fee: number;
+    counter: number;
+    gas_limit: number;
+    storage_limit: number;
+}
+export interface TezosDelegationOperation {
+    source: string;
+    delegate: string;
+    fee: number;
+    counter: number;
+    gas_limit: number;
+    storage_limit: number;
+}
+export interface TezosOperation {
+    reveal?: TezosRevealOperation;
+    transaction?: TezosTransactionOperation;
+    origination?: TezosOriginationOperation;
+    delegation?: TezosDelegationOperation;
+}
+export interface TezosSignTransaction {
+    path: string | number[];
+    branch: string;
+    operation: TezosOperation;
+}
+export declare function tezosSignTransaction(params: Params<TezosSignTransaction>): Response<PROTO.TezosSignedTx>;
+//# sourceMappingURL=tezosSignTransaction.d.ts.map

package/lib/types/api/tezosSignTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tezosSignTransaction.js.map

package/lib/types/api/uiResponse.d.ts

@@ -0,0 +1,3 @@
+import type { UiResponseEvent } from '../../events/ui-response';
+export declare function uiResponse(response: UiResponseEvent): void;
+//# sourceMappingURL=uiResponse.d.ts.map

package/lib/types/api/uiResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=uiResponse.js.map

package/lib/types/api/verifyMessage.d.ts

@@ -0,0 +1,11 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface VerifyMessage {
+    address: string;
+    signature: string;
+    message: string;
+    coin: string;
+    hex?: boolean;
+}
+export declare function verifyMessage(params: Params<VerifyMessage>): Response<PROTO.Success>;
+//# sourceMappingURL=verifyMessage.d.ts.map

package/lib/types/api/verifyMessage.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=verifyMessage.js.map

package/lib/types/api/wipeDevice.d.ts

@@ -0,0 +1,4 @@
+import type { PROTO } from '../../constants';
+import type { CommonParams, Response } from '../params';
+export declare function wipeDevice(params?: CommonParams): Response<PROTO.Success>;
+//# sourceMappingURL=wipeDevice.d.ts.map

package/lib/types/api/wipeDevice.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=wipeDevice.js.map