@trezor/connect 9.0.0-beta.1

package/lib/types/api/blockchainGetAccountBalanceHistory.js

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

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

@@ -0,0 +1,4 @@
+import type { BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { CommonParamsWithCoin, Response } from '../params';
+export declare function blockchainGetCurrentFiatRates(params: CommonParamsWithCoin & BlockchainLinkParams<'getCurrentFiatRates'>): Response<BlockchainLinkResponse<'getCurrentFiatRates'>>;
+//# sourceMappingURL=blockchainGetCurrentFiatRates.d.ts.map

package/lib/types/api/blockchainGetCurrentFiatRates.js

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

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

@@ -0,0 +1,4 @@
+import type { BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { CommonParamsWithCoin, Response } from '../params';
+export declare function blockchainGetFiatRatesForTimestamps(params: CommonParamsWithCoin & BlockchainLinkParams<'getFiatRatesForTimestamps'>): Response<BlockchainLinkResponse<'getFiatRatesForTimestamps'>>;
+//# sourceMappingURL=blockchainGetFiatRatesForTimestamps.d.ts.map

package/lib/types/api/blockchainGetFiatRatesForTimestamps.js

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

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

@@ -0,0 +1,7 @@
+import type { TypedRawTransaction } from '@trezor/blockchain-link';
+import type { CommonParamsWithCoin, Response } from '../params';
+export declare type BlockchainGetTransactions = CommonParamsWithCoin & {
+    txs: string[];
+};
+export declare function blockchainGetTransactions(params: BlockchainGetTransactions): Response<TypedRawTransaction[]>;
+//# sourceMappingURL=blockchainGetTransactions.d.ts.map

package/lib/types/api/blockchainGetTransactions.js

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

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

@@ -0,0 +1,7 @@
+import type { CommonParamsWithCoin, Response } from '../params';
+import type { BlockchainLink } from '../coinInfo';
+export declare type BlockchainSetCustomBackend = CommonParamsWithCoin & {
+    blockchainLink?: BlockchainLink;
+};
+export declare function blockchainSetCustomBackend(params: BlockchainSetCustomBackend): Response<boolean>;
+//# sourceMappingURL=blockchainSetCustomBackend.d.ts.map

package/lib/types/api/blockchainSetCustomBackend.js

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

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

@@ -0,0 +1,7 @@
+import type { SubscriptionAccountInfo, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { CommonParamsWithCoin, Response } from '../params';
+export declare type BlockchainSubscribe = CommonParamsWithCoin & {
+    accounts?: SubscriptionAccountInfo[];
+};
+export declare function blockchainSubscribe(params: BlockchainSubscribe): Response<BlockchainLinkResponse<'subscribe'>>;
+//# sourceMappingURL=blockchainSubscribe.d.ts.map

package/lib/types/api/blockchainSubscribe.js

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

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

@@ -0,0 +1,7 @@
+import type { BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { CommonParamsWithCoin, Response } from '../params';
+export declare type BlockchainSubscribeFiatRates = CommonParamsWithCoin & {
+    currency?: string;
+};
+export declare function blockchainSubscribeFiatRates(params: BlockchainSubscribeFiatRates): Response<BlockchainLinkResponse<'subscribe'>>;
+//# sourceMappingURL=blockchainSubscribeFiatRates.d.ts.map

package/lib/types/api/blockchainSubscribeFiatRates.js

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

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

@@ -0,0 +1,5 @@
+import type { BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { Response } from '../params';
+import type { BlockchainSubscribe } from './blockchainSubscribe';
+export declare function blockchainUnsubscribe(params: BlockchainSubscribe): Response<BlockchainLinkResponse<'unsubscribe'>>;
+//# sourceMappingURL=blockchainUnsubscribe.d.ts.map

package/lib/types/api/blockchainUnsubscribe.js

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

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

@@ -0,0 +1,5 @@
+import type { BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { Response } from '../params';
+import type { BlockchainSubscribeFiatRates } from './blockchainSubscribeFiatRates';
+export declare function blockchainUnsubscribeFiatRates(params: BlockchainSubscribeFiatRates): Response<BlockchainLinkResponse<'unsubscribe'>>;
+//# sourceMappingURL=blockchainUnsubscribeFiatRates.d.ts.map

package/lib/types/api/blockchainUnsubscribeFiatRates.js

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

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

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

package/lib/types/api/cancel.js

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

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

@@ -0,0 +1,35 @@
+import type { PROTO } from '../../constants';
+import type { Params, BundledParams, Response } from '../params';
+export interface CardanoCertificatePointer {
+    blockIndex: number;
+    txIndex: number;
+    certificateIndex: number;
+}
+export interface CardanoAddressParameters {
+    addressType: PROTO.CardanoAddressType;
+    path?: string | number[];
+    stakingPath?: string | number[];
+    stakingKeyHash?: string;
+    certificatePointer?: CardanoCertificatePointer;
+    paymentScriptHash?: string;
+    stakingScriptHash?: string;
+}
+export interface CardanoGetAddress {
+    addressParameters: CardanoAddressParameters;
+    protocolMagic: number;
+    networkId: number;
+    address?: string;
+    showOnTrezor?: boolean;
+    derivationType?: PROTO.CardanoDerivationType;
+}
+export interface CardanoAddress {
+    addressParameters: CardanoAddressParameters;
+    protocolMagic: number;
+    networkId: number;
+    serializedPath: string;
+    serializedStakingPath: string;
+    address: string;
+}
+export declare function cardanoGetAddress(params: Params<CardanoGetAddress>): Response<CardanoAddress>;
+export declare function cardanoGetAddress(params: BundledParams<CardanoGetAddress>): Response<CardanoAddress[]>;
+//# sourceMappingURL=cardanoGetAddress.d.ts.map

package/lib/types/api/cardanoGetAddress.js

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

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

@@ -0,0 +1,21 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface CardanoNativeScript {
+    type: PROTO.CardanoNativeScriptType;
+    scripts?: CardanoNativeScript[];
+    keyHash?: string;
+    keyPath?: string | number[];
+    requiredSignaturesCount?: number;
+    invalidBefore?: string;
+    invalidHereafter?: string;
+}
+export interface CardanoGetNativeScriptHash {
+    script: CardanoNativeScript;
+    displayFormat: PROTO.CardanoNativeScriptHashDisplayFormat;
+    derivationType?: PROTO.CardanoDerivationType;
+}
+export interface CardanoNativeScriptHash {
+    scriptHash: string;
+}
+export declare function cardanoGetNativeScriptHash(params: Params<CardanoGetNativeScriptHash>): Response<CardanoNativeScriptHash>;
+//# sourceMappingURL=cardanoGetNativeScriptHash.d.ts.map

package/lib/types/api/cardanoGetNativeScriptHash.js

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

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

@@ -0,0 +1,16 @@
+import type { PROTO } from '../../constants';
+import type { Params, BundledParams, Response } from '../params';
+export interface CardanoGetPublicKey {
+    path: string | number[];
+    showOnTrezor?: boolean;
+    derivationType?: PROTO.CardanoDerivationType;
+}
+export interface CardanoPublicKey {
+    path: number[];
+    serializedPath: string;
+    publicKey: string;
+    node: PROTO.HDNodeType;
+}
+export declare function cardanoGetPublicKey(params: Params<CardanoGetPublicKey>): Response<CardanoPublicKey>;
+export declare function cardanoGetPublicKey(params: BundledParams<CardanoGetPublicKey>): Response<CardanoPublicKey[]>;
+//# sourceMappingURL=cardanoGetPublicKey.d.ts.map

package/lib/types/api/cardanoGetPublicKey.js

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

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

@@ -0,0 +1,130 @@
+import type { PROTO } from '../../constants';
+import type { CardanoAddressParameters } from './cardanoGetAddress';
+import type { Params, Response } from '../params';
+export interface CardanoInput {
+    path?: string | number[];
+    prev_hash: string;
+    prev_index: number;
+}
+export interface CardanoToken {
+    assetNameBytes: string;
+    amount?: string;
+    mintAmount?: string;
+}
+export interface CardanoAssetGroup {
+    policyId: string;
+    tokenAmounts: CardanoToken[];
+}
+export declare type CardanoOutput = {
+    addressParameters: CardanoAddressParameters;
+    amount: string;
+    tokenBundle?: CardanoAssetGroup[];
+    datumHash?: string;
+} | {
+    address: string;
+    amount: string;
+    tokenBundle?: CardanoAssetGroup[];
+    datumHash?: string;
+};
+export interface CardanoPoolOwner {
+    stakingKeyPath?: string | number[];
+    stakingKeyHash?: string;
+}
+export interface CardanoPoolRelay {
+    type: PROTO.CardanoPoolRelayType;
+    ipv4Address?: string;
+    ipv6Address?: string;
+    port?: number;
+    hostName?: string;
+}
+export interface CardanoPoolMetadata {
+    url: string;
+    hash: string;
+}
+export interface CardanoPoolMargin {
+    numerator: string;
+    denominator: string;
+}
+export interface CardanoPoolParameters {
+    poolId: string;
+    vrfKeyHash: string;
+    pledge: string;
+    cost: string;
+    margin: CardanoPoolMargin;
+    rewardAccount: string;
+    owners: CardanoPoolOwner[];
+    relays: CardanoPoolRelay[];
+    metadata: CardanoPoolMetadata;
+}
+export interface CardanoCertificate {
+    type: PROTO.CardanoCertificateType;
+    path?: string | number[];
+    pool?: string;
+    poolParameters?: CardanoPoolParameters;
+    scriptHash?: string;
+    keyHash?: string;
+}
+export interface CardanoWithdrawal {
+    path?: string | number[];
+    amount: string;
+    scriptHash?: string;
+    keyHash?: string;
+}
+export declare type CardanoMint = CardanoAssetGroup[];
+export interface CardanoCollateralInput {
+    path?: string | number[];
+    prev_hash: string;
+    prev_index: number;
+}
+export interface CardanoRequiredSigner {
+    keyPath?: string | number[];
+    keyHash?: string;
+}
+export interface CardanoCatalystRegistrationParameters {
+    votingPublicKey: string;
+    stakingPath: string | number[];
+    rewardAddressParameters: CardanoAddressParameters;
+    nonce: string;
+}
+export interface CardanoAuxiliaryData {
+    hash?: string;
+    catalystRegistrationParameters?: CardanoCatalystRegistrationParameters;
+}
+export interface CardanoSignTransaction {
+    inputs: CardanoInput[];
+    outputs: CardanoOutput[];
+    fee: string;
+    ttl?: string;
+    certificates?: CardanoCertificate[];
+    withdrawals?: CardanoWithdrawal[];
+    validityIntervalStart?: string;
+    auxiliaryData?: CardanoAuxiliaryData;
+    mint?: CardanoMint;
+    scriptDataHash?: string;
+    collateralInputs?: CardanoCollateralInput[];
+    requiredSigners?: CardanoRequiredSigner[];
+    additionalWitnessRequests?: (string | number[])[];
+    protocolMagic: number;
+    networkId: number;
+    signingMode: PROTO.CardanoTxSigningMode;
+    derivationType?: PROTO.CardanoDerivationType;
+    includeNetworkId?: boolean;
+}
+export interface CardanoSignedTxWitness {
+    type: PROTO.CardanoTxWitnessType;
+    pubKey: string;
+    signature: string;
+    chainCode?: string;
+}
+export interface CardanoAuxiliaryDataSupplement {
+    type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+    auxiliaryDataHash: string;
+    catalystSignature?: string;
+}
+export interface CardanoSignedTxData {
+    hash: string;
+    witnesses: CardanoSignedTxWitness[];
+    auxiliaryDataSupplement?: CardanoAuxiliaryDataSupplement;
+}
+export declare function cardanoSignTransaction(params: Params<CardanoSignTransaction>): Response<CardanoSignedTxData>;
+//# sourceMappingURL=cardanoSignTransaction.d.ts.map

package/lib/types/api/cardanoSignTransaction.js

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

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

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

package/lib/types/api/changePin.js

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

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

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { Params, BundledParams, Response } from '../params';
+export interface CipherKeyValue {
+    path: string | number[];
+    key: string;
+    value: string | Buffer;
+    encrypt?: boolean;
+    askOnEncrypt?: boolean;
+    askOnDecrypt?: boolean;
+    iv?: string | Buffer;
+}
+export interface CipheredValue {
+    value: string;
+}
+export declare function cipherKeyValue(params: Params<CipherKeyValue>): Response<CipheredValue>;
+export declare function cipherKeyValue(params: BundledParams<CipherKeyValue>): Response<CipheredValue[]>;
+//# sourceMappingURL=cipherKeyValue.d.ts.map

package/lib/types/api/cipherKeyValue.js

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

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

@@ -0,0 +1,92 @@
+import type { PROTO } from '../../constants';
+import type { AccountAddresses, Utxo as AccountUtxo } from '@trezor/blockchain-link';
+import type { Params, Response } from '../params';
+export interface RegularOutput {
+    type?: 'external';
+    address: string;
+    amount: string;
+    script_type?: 'PAYTOADDRESS';
+}
+export interface InternalOutput {
+    type?: 'internal';
+    address_n: number[];
+    amount: string;
+    script_type?: string;
+}
+export interface SendMaxOutput {
+    type: 'send-max';
+    address: string;
+}
+export interface OpReturnOutput {
+    type: 'opreturn';
+    dataHex: string;
+}
+export interface NoAddressOutput {
+    type: 'noaddress';
+    amount: string;
+}
+export interface NoAddressSendMaxOutput {
+    type: 'send-max-noaddress';
+}
+export declare type ComposeOutput = RegularOutput | InternalOutput | SendMaxOutput | OpReturnOutput | NoAddressOutput | NoAddressSendMaxOutput;
+export interface ComposeParams {
+    outputs: ComposeOutput[];
+    coin: string;
+    account?: undefined;
+    feeLevels?: undefined;
+    push?: boolean;
+    sequence?: number;
+    baseFee?: number;
+    floorBaseFee?: boolean;
+    skipPermutation?: boolean;
+}
+export declare type SignedTransaction = {
+    signatures: string[];
+    serializedTx: string;
+    txid?: string;
+};
+export interface PrecomposeParams {
+    outputs: ComposeOutput[];
+    coin: string;
+    account: {
+        path: string;
+        addresses: AccountAddresses;
+        utxo: (AccountUtxo & {
+            required?: boolean;
+        })[];
+    };
+    feeLevels: {
+        feePerUnit: string;
+    }[];
+    push?: undefined;
+    baseFee?: number;
+    floorBaseFee?: boolean;
+    sequence?: number;
+    skipPermutation?: boolean;
+}
+export declare type PrecomposedTransaction = {
+    type: 'error';
+    error: string;
+} | {
+    type: 'nonfinal';
+    max?: string;
+    totalSpent: string;
+    fee: string;
+    feePerByte: string;
+    bytes: number;
+} | {
+    type: 'final';
+    max?: string;
+    totalSpent: string;
+    fee: string;
+    feePerByte: string;
+    bytes: number;
+    transaction: {
+        inputs: PROTO.TxInputType[];
+        outputs: PROTO.TxOutputType[];
+        outputsPermutation: number[];
+    };
+};
+export declare function composeTransaction(params: Params<ComposeParams>): Response<SignedTransaction>;
+export declare function composeTransaction(params: Params<PrecomposeParams>): Response<PrecomposedTransaction[]>;
+//# sourceMappingURL=composeTransaction.d.ts.map

package/lib/types/api/composeTransaction.js

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

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

@@ -0,0 +1,12 @@
+import type { Params, Response } from '../params';
+export interface CustomMessage {
+    messages?: JSON | Record<string, any>;
+    message: string;
+    params: JSON | Record<string, any>;
+    callback: (request: any) => Promise<{
+        message: string;
+        params?: Record<string, any>;
+    }>;
+}
+export declare function customMessage<R extends Record<string, any>>(params: Params<CustomMessage>): Response<R>;
+//# sourceMappingURL=customMessage.d.ts.map

package/lib/types/api/customMessage.js

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

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

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

package/lib/types/api/disableWebUSB.js

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

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

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

package/lib/types/api/dispose.js

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

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

@@ -0,0 +1,14 @@
+import type { Params, BundledParams, Response } from '../params';
+export interface EosGetPublicKey {
+    path: string | number[];
+    showOnTrezor?: boolean;
+}
+export interface EosPublicKey {
+    wifPublicKey: string;
+    rawPublicKey: string;
+    path: number[];
+    serializedPath: string;
+}
+export declare function eosGetPublicKey(params: Params<EosGetPublicKey>): Response<EosPublicKey>;
+export declare function eosGetPublicKey(params: BundledParams<EosGetPublicKey>): Response<EosPublicKey[]>;
+//# sourceMappingURL=eosGetPublicKey.d.ts.map

package/lib/types/api/eosGetPublicKey.js

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

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

@@ -0,0 +1,111 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface EosTxHeader {
+    expiration: PROTO.UintType;
+    refBlockNum: number;
+    refBlockPrefix: number;
+    maxNetUsageWords: number;
+    maxCpuUsageMs: number;
+    delaySec: number;
+}
+export interface EosAuthorization {
+    threshold: number;
+    keys: PROTO.EosAuthorizationKey[];
+    accounts: {
+        permission: PROTO.EosPermissionLevel;
+        weight: number;
+    }[];
+    waits: PROTO.EosAuthorizationWait[];
+}
+export interface EosTxActionCommon {
+    account: string;
+    authorization: PROTO.EosPermissionLevel[];
+}
+export declare type EosTxAction = (EosTxActionCommon & {
+    name: 'transfer';
+    data: {
+        from: string;
+        to: string;
+        quantity: string;
+        memo: string;
+    };
+}) | (EosTxActionCommon & {
+    name: 'delegatebw';
+    data: {
+        from: string;
+        receiver: string;
+        stake_net_quantity: string;
+        stake_cpu_quantity: string;
+        transfer: boolean;
+    };
+}) | (EosTxActionCommon & {
+    name: 'undelegatebw';
+    data: {
+        from: string;
+        receiver: string;
+        unstake_net_quantity: string;
+        unstake_cpu_quantity: string;
+    };
+}) | (EosTxActionCommon & {
+    name: 'buyram';
+    data: {
+        payer: string;
+        receiver: string;
+        quant: string;
+    };
+}) | (EosTxActionCommon & {
+    name: 'buyrambytes';
+    data: PROTO.EosActionBuyRamBytes;
+}) | (EosTxActionCommon & {
+    name: 'sellram';
+    data: PROTO.EosActionSellRam;
+}) | (EosTxActionCommon & {
+    name: 'voteproducer';
+    data: {
+        voter: string;
+        proxy: string;
+        producers: string[];
+    };
+}) | (EosTxActionCommon & {
+    name: 'refund';
+    data: PROTO.EosActionRefund;
+}) | (EosTxActionCommon & {
+    name: 'updateauth';
+    data: {
+        account: string;
+        permission: string;
+        parent: string;
+        auth: EosAuthorization;
+    };
+}) | (EosTxActionCommon & {
+    name: 'deleteauth';
+    data: PROTO.EosActionDeleteAuth;
+}) | (EosTxActionCommon & {
+    name: 'linkauth';
+    data: PROTO.EosActionLinkAuth;
+}) | (EosTxActionCommon & {
+    name: 'unlinkauth';
+    data: PROTO.EosActionUnlinkAuth;
+}) | (EosTxActionCommon & {
+    name: 'newaccount';
+    data: {
+        creator: string;
+        name: string;
+        owner: EosAuthorization;
+        active: EosAuthorization;
+    };
+});
+export interface EosSDKTransaction {
+    chainId: string;
+    header: EosTxHeader;
+    actions: Array<EosTxAction | (EosTxActionCommon & {
+        name: string;
+        data: string;
+    })>;
+}
+export interface EosSignTransaction {
+    path: string | number[];
+    transaction: EosSDKTransaction;
+}
+export declare function eosSignTransaction(params: Params<EosSignTransaction>): Response<PROTO.EosSignedTx>;
+//# sourceMappingURL=eosSignTransaction.d.ts.map

package/lib/types/api/eosSignTransaction.js

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

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

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