@trezor/connect 9.1.8 → 9.1.10

package/lib/types/api/nem/index.js

@@ -1,3 +1,133 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEMSignTransaction = exports.NEMTransaction = exports.NEMMultisigTransaction = exports.NEMRegularTransaction = exports.NEMSupplyChangeTransaction = exports.NEMMosaicCreationTransaction = exports.NEMProvisionNamespaceTransaction = exports.NEMAggregateModificationTransaction = exports.NEMImportanceTransaction = exports.NEMTransferTransaction = exports.TransactionCommon = exports.Message = exports.Modification = exports.NEMMosaic = exports.MosaicDefinition = exports.MosaicID = void 0;
+const constants_1 = require("../../../constants");
+const params_1 = require("../../params");
+const schema_utils_1 = require("@trezor/schema-utils");
+exports.MosaicID = schema_utils_1.Type.Object({
+    namespaceId: schema_utils_1.Type.String(),
+    name: schema_utils_1.Type.String(),
+});
+exports.MosaicDefinition = schema_utils_1.Type.Object({
+    levy: schema_utils_1.Type.Optional(schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Optional(constants_1.PROTO.EnumNEMMosaicLevy),
+        fee: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+        recipient: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+        mosaicId: schema_utils_1.Type.Optional(exports.MosaicID),
+    })),
+    id: exports.MosaicID,
+    description: schema_utils_1.Type.String(),
+    properties: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Object({
+        name: schema_utils_1.Type.Union([
+            schema_utils_1.Type.Literal('divisibility'),
+            schema_utils_1.Type.Literal('initialSupply'),
+            schema_utils_1.Type.Literal('supplyMutable'),
+            schema_utils_1.Type.Literal('transferable'),
+        ]),
+        value: schema_utils_1.Type.String(),
+    }))),
+});
+exports.NEMMosaic = schema_utils_1.Type.Object({
+    mosaicId: exports.MosaicID,
+    quantity: schema_utils_1.Type.Number(),
+});
+exports.Modification = schema_utils_1.Type.Object({
+    modificationType: constants_1.PROTO.EnumNEMModificationType,
+    cosignatoryAccount: schema_utils_1.Type.String(),
+});
+exports.Message = schema_utils_1.Type.Object({
+    payload: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    type: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    publicKey: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+});
+exports.TransactionCommon = schema_utils_1.Type.Object({
+    version: constants_1.NEM.EnumTxVersion,
+    timeStamp: schema_utils_1.Type.Number(),
+    fee: schema_utils_1.Type.Number(),
+    deadline: schema_utils_1.Type.Number(),
+    signer: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+});
+exports.NEMTransferTransaction = schema_utils_1.Type.Intersect([
+    exports.TransactionCommon,
+    schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Literal(constants_1.NEM.TxType.TRANSFER),
+        recipient: schema_utils_1.Type.String(),
+        amount: schema_utils_1.Type.Uint(),
+        mosaics: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.NEMMosaic)),
+        message: schema_utils_1.Type.Optional(exports.Message),
+    }),
+]);
+exports.NEMImportanceTransaction = schema_utils_1.Type.Intersect([
+    exports.TransactionCommon,
+    schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Literal(constants_1.NEM.TxType.IMPORTANCE_TRANSFER),
+        importanceTransfer: schema_utils_1.Type.Object({
+            mode: constants_1.PROTO.EnumNEMImportanceTransferMode,
+            publicKey: schema_utils_1.Type.String(),
+        }),
+    }),
+]);
+exports.NEMAggregateModificationTransaction = schema_utils_1.Type.Intersect([
+    exports.TransactionCommon,
+    schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Literal(constants_1.NEM.TxType.AGGREGATE_MODIFICATION),
+        modifications: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.Modification)),
+        minCosignatories: schema_utils_1.Type.Object({
+            relativeChange: schema_utils_1.Type.Number(),
+        }),
+    }),
+]);
+exports.NEMProvisionNamespaceTransaction = schema_utils_1.Type.Intersect([
+    exports.TransactionCommon,
+    schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Literal(constants_1.NEM.TxType.PROVISION_NAMESPACE),
+        newPart: schema_utils_1.Type.String(),
+        parent: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+        rentalFeeSink: schema_utils_1.Type.String(),
+        rentalFee: schema_utils_1.Type.Number(),
+    }),
+]);
+exports.NEMMosaicCreationTransaction = schema_utils_1.Type.Intersect([
+    exports.TransactionCommon,
+    schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Literal(constants_1.NEM.TxType.MOSAIC_CREATION),
+        mosaicDefinition: exports.MosaicDefinition,
+        creationFeeSink: schema_utils_1.Type.String(),
+        creationFee: schema_utils_1.Type.Number(),
+    }),
+]);
+exports.NEMSupplyChangeTransaction = schema_utils_1.Type.Intersect([
+    exports.TransactionCommon,
+    schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Literal(constants_1.NEM.TxType.SUPPLY_CHANGE),
+        mosaicId: exports.MosaicID,
+        supplyType: constants_1.PROTO.EnumNEMSupplyChangeType,
+        delta: schema_utils_1.Type.Number(),
+    }),
+]);
+exports.NEMRegularTransaction = schema_utils_1.Type.Union([
+    exports.NEMTransferTransaction,
+    exports.NEMImportanceTransaction,
+    exports.NEMAggregateModificationTransaction,
+    exports.NEMProvisionNamespaceTransaction,
+    exports.NEMMosaicCreationTransaction,
+    exports.NEMSupplyChangeTransaction,
+]);
+exports.NEMMultisigTransaction = schema_utils_1.Type.Intersect([
+    exports.TransactionCommon,
+    schema_utils_1.Type.Object({
+        type: schema_utils_1.Type.Union([
+            schema_utils_1.Type.Literal(constants_1.NEM.TxType.COSIGNING),
+            schema_utils_1.Type.Literal(constants_1.NEM.TxType.MULTISIG),
+            schema_utils_1.Type.Literal(constants_1.NEM.TxType.MULTISIG_SIGNATURE),
+        ]),
+        otherTrans: exports.NEMRegularTransaction,
+    }),
+]);
+exports.NEMTransaction = schema_utils_1.Type.Union([exports.NEMRegularTransaction, exports.NEMMultisigTransaction]);
+exports.NEMSignTransaction = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    transaction: exports.NEMTransaction,
+    chunkify: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+});
 //# sourceMappingURL=index.js.map

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

@@ -1,8 +1,10 @@
+import { Static } from '@trezor/schema-utils';
 import type { Params, Response } from '../params';
-export type PushTransaction = {
-    tx: string;
-    coin: string;
-};
+export type PushTransaction = Static<typeof PushTransaction>;
+export declare const PushTransaction: import("@sinclair/typebox").TObject<{
+    tx: import("@sinclair/typebox").TString;
+    coin: import("@sinclair/typebox").TString;
+}>;
 export interface PushedTransaction {
     txid: string;
 }

package/lib/types/api/pushTransaction.js

@@ -1,3 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushTransaction = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+exports.PushTransaction = schema_utils_1.Type.Object({
+    tx: schema_utils_1.Type.String(),
+    coin: schema_utils_1.Type.String(),
+});
 //# sourceMappingURL=pushTransaction.js.map

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

@@ -1,7 +1,17 @@
-import type { PROTO } from '../../constants';
+import { Static } from '@trezor/schema-utils';
+import { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
-export interface RecoveryDevice extends Omit<PROTO.RecoveryDevice, 'word_count'> {
-    word_count?: 12 | 18 | 24;
-}
+export type RecoveryDevice = Static<typeof RecoveryDevice>;
+export declare const RecoveryDevice: import("@sinclair/typebox").TObject<{
+    language: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<typeof PROTO.RecoveryDeviceType>>;
+    pin_protection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    passphrase_protection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    word_count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<12>, import("@sinclair/typebox").TLiteral<18>, import("@sinclair/typebox").TLiteral<24>]>]>>;
+    enforce_wordlist: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    u2f_counter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    dry_run: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
 export declare function recoveryDevice(params: Params<RecoveryDevice>): Response<PROTO.Success>;
 //# sourceMappingURL=recoveryDevice.d.ts.map

package/lib/types/api/recoveryDevice.js

@@ -1,3 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecoveryDevice = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../constants");
+exports.RecoveryDevice = schema_utils_1.Type.Composite([
+    constants_1.PROTO.RecoveryDevice,
+    schema_utils_1.Type.Object({
+        word_count: schema_utils_1.Type.Optional(schema_utils_1.Type.Union([schema_utils_1.Type.Literal(12), schema_utils_1.Type.Literal(18), schema_utils_1.Type.Literal(24)])),
+    }),
+]);
 //# sourceMappingURL=recoveryDevice.js.map

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

@@ -1,20 +1,45 @@
+import { Static } from '@trezor/schema-utils';
 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 type LoginChallenge = Static<typeof LoginChallenge>;
+export declare const LoginChallenge: import("@sinclair/typebox").TObject<{
+    challengeHidden: import("@sinclair/typebox").TString;
+    challengeVisual: import("@sinclair/typebox").TString;
+    asyncChallenge: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    callback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+}>;
+export type RequestLoginAsync = Static<typeof RequestLoginAsync>;
+export declare const RequestLoginAsync: import("@sinclair/typebox").TObject<{
+    challengeHidden: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    challengeVisual: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    asyncChallenge: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    callback: import("@sinclair/typebox").TFunction<[], import("@sinclair/typebox").TObject<{
+        challengeHidden: import("@sinclair/typebox").TString;
+        challengeVisual: import("@sinclair/typebox").TString;
+        asyncChallenge: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+        callback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    }>>;
+}>;
+export type RequestLoginSchema = Static<typeof RequestLoginSchema>;
+export declare const RequestLoginSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    challengeHidden: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    challengeVisual: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    asyncChallenge: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    callback: import("@sinclair/typebox").TFunction<[], import("@sinclair/typebox").TObject<{
+        challengeHidden: import("@sinclair/typebox").TString;
+        challengeVisual: import("@sinclair/typebox").TString;
+        asyncChallenge: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+        callback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    }>>;
+}>, import("@sinclair/typebox").TObject<{
+    challengeHidden: import("@sinclair/typebox").TString;
+    challengeVisual: import("@sinclair/typebox").TString;
+    asyncChallenge: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+    callback: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUndefined>;
+}>]>;
 export interface Login {
     address: string;
     publicKey: string;
     signature: string;
 }
-export declare function requestLogin(params: Params<RequestLoginAsync | LoginChallenge>): Response<Login>;
+export declare function requestLogin(params: Params<RequestLoginSchema>): Response<Login>;
 //# sourceMappingURL=requestLogin.d.ts.map

package/lib/types/api/requestLogin.js

@@ -1,3 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLoginSchema = exports.RequestLoginAsync = exports.LoginChallenge = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+exports.LoginChallenge = schema_utils_1.Type.Object({
+    challengeHidden: schema_utils_1.Type.String(),
+    challengeVisual: schema_utils_1.Type.String(),
+    asyncChallenge: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
+    callback: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
+});
+exports.RequestLoginAsync = schema_utils_1.Type.Object({
+    challengeHidden: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
+    challengeVisual: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
+    asyncChallenge: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+    callback: schema_utils_1.Type.Function([], exports.LoginChallenge),
+});
+exports.RequestLoginSchema = schema_utils_1.Type.Union([exports.RequestLoginAsync, exports.LoginChallenge]);
 //# sourceMappingURL=requestLogin.js.map

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

@@ -1,16 +1,18 @@
-import type { PROTO } from '../../constants';
+import { Static } from '@trezor/schema-utils';
+import { 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 type ResetDevice = Static<typeof ResetDevice>;
+export declare const ResetDevice: import("@sinclair/typebox").TObject<{
+    language: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    pin_protection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    passphrase_protection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    u2f_counter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    no_backup: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    backup_type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<0>, import("@sinclair/typebox").TLiteral<1>]>]>>;
+    display_random: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    strength: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    skip_backup: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
 export declare function resetDevice(params: Params<ResetDevice>): Response<PROTO.Success>;
 //# sourceMappingURL=resetDevice.d.ts.map

package/lib/types/api/resetDevice.js

@@ -1,3 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResetDevice = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../constants");
+exports.ResetDevice = schema_utils_1.Type.Composite([
+    constants_1.PROTO.ResetDevice,
+    schema_utils_1.Type.Object({
+        backup_type: schema_utils_1.Type.Optional(schema_utils_1.Type.Union([schema_utils_1.Type.Literal(0), schema_utils_1.Type.Literal(1)])),
+    }),
+]);
 //# sourceMappingURL=resetDevice.js.map

package/lib/types/api/ripple/index.d.ts

@@ -1,23 +1,41 @@
-import type { DerivationPath } 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: DerivationPath;
-    transaction: RippleTransaction;
-    chunkify?: boolean;
-}
-export interface RippleSignedTx {
-    serializedTx: string;
-    signature: string;
-}
+import { Static } from '@trezor/schema-utils';
+export type RipplePayment = Static<typeof RipplePayment>;
+export declare const RipplePayment: import("@sinclair/typebox").TObject<{
+    amount: import("@sinclair/typebox").TString;
+    destination: import("@sinclair/typebox").TString;
+    destinationTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type RippleTransaction = Static<typeof RippleTransaction>;
+export declare const RippleTransaction: import("@sinclair/typebox").TObject<{
+    fee: import("@sinclair/typebox").TString;
+    flags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    sequence: import("@sinclair/typebox").TNumber;
+    maxLedgerVersion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    payment: import("@sinclair/typebox").TObject<{
+        amount: import("@sinclair/typebox").TString;
+        destination: import("@sinclair/typebox").TString;
+        destinationTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>;
+}>;
+export type RippleSignTransaction = Static<typeof RippleSignTransaction>;
+export declare const RippleSignTransaction: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
+    transaction: import("@sinclair/typebox").TObject<{
+        fee: import("@sinclair/typebox").TString;
+        flags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        sequence: import("@sinclair/typebox").TNumber;
+        maxLedgerVersion: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        payment: import("@sinclair/typebox").TObject<{
+            amount: import("@sinclair/typebox").TString;
+            destination: import("@sinclair/typebox").TString;
+            destinationTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        }>;
+    }>;
+    chunkify: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export type RippleSignedTx = Static<typeof RippleSignedTx>;
+export declare const RippleSignedTx: import("@sinclair/typebox").TObject<{
+    serializedTx: import("@sinclair/typebox").TString;
+    signature: import("@sinclair/typebox").TString;
+}>;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/api/ripple/index.js

@@ -1,3 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RippleSignedTx = exports.RippleSignTransaction = exports.RippleTransaction = exports.RipplePayment = void 0;
+const params_1 = require("../../params");
+const schema_utils_1 = require("@trezor/schema-utils");
+exports.RipplePayment = schema_utils_1.Type.Object({
+    amount: schema_utils_1.Type.String(),
+    destination: schema_utils_1.Type.String(),
+    destinationTag: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+});
+exports.RippleTransaction = schema_utils_1.Type.Object({
+    fee: schema_utils_1.Type.String(),
+    flags: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    sequence: schema_utils_1.Type.Number(),
+    maxLedgerVersion: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    payment: exports.RipplePayment,
+});
+exports.RippleSignTransaction = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    transaction: exports.RippleTransaction,
+    chunkify: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+});
+exports.RippleSignedTx = schema_utils_1.Type.Object({
+    serializedTx: schema_utils_1.Type.String(),
+    signature: schema_utils_1.Type.String(),
+});
 //# sourceMappingURL=index.js.map

package/lib/types/api/solana/index.d.ts

@@ -1,22 +1,43 @@
-import type { PublicKey } from '../../params';
-export interface SolanaPublicKey extends PublicKey {
-    publicKey: string;
-}
-export interface SolanaTxTokenAccountInfo {
-    baseAddress: string;
-    tokenProgram: string;
-    tokenMint: string;
-    tokenAccount: string;
-}
-export interface SolanaTxAdditionalInfo {
-    tokenAccountsInfos?: SolanaTxTokenAccountInfo[];
-}
-export interface SolanaSignTransaction {
-    path: string | number[];
-    serializedTx: string;
-    additionalInfo?: SolanaTxAdditionalInfo;
-}
-export interface SolanaSignedTransaction {
-    signature: string;
-}
+import { Static } from '@trezor/schema-utils';
+export type SolanaPublicKey = Static<typeof SolanaPublicKey>;
+export declare const SolanaPublicKey: import("@sinclair/typebox").TIntersect<[import("@sinclair/typebox").TObject<{
+    publicKey: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
+    serializedPath: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    publicKey: import("@sinclair/typebox").TString;
+}>]>;
+export type SolanaTxTokenAccountInfo = Static<typeof SolanaTxTokenAccountInfo>;
+export declare const SolanaTxTokenAccountInfo: import("@sinclair/typebox").TObject<{
+    baseAddress: import("@sinclair/typebox").TString;
+    tokenProgram: import("@sinclair/typebox").TString;
+    tokenMint: import("@sinclair/typebox").TString;
+    tokenAccount: import("@sinclair/typebox").TString;
+}>;
+export type SolanaTxAdditionalInfo = Static<typeof SolanaTxAdditionalInfo>;
+export declare const SolanaTxAdditionalInfo: import("@sinclair/typebox").TObject<{
+    tokenAccountsInfos: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        baseAddress: import("@sinclair/typebox").TString;
+        tokenProgram: import("@sinclair/typebox").TString;
+        tokenMint: import("@sinclair/typebox").TString;
+        tokenAccount: import("@sinclair/typebox").TString;
+    }>>>;
+}>;
+export type SolanaSignTransaction = Static<typeof SolanaSignTransaction>;
+export declare const SolanaSignTransaction: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
+    serializedTx: import("@sinclair/typebox").TString;
+    additionalInfo: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        tokenAccountsInfos: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            baseAddress: import("@sinclair/typebox").TString;
+            tokenProgram: import("@sinclair/typebox").TString;
+            tokenMint: import("@sinclair/typebox").TString;
+            tokenAccount: import("@sinclair/typebox").TString;
+        }>>>;
+    }>>;
+}>;
+export type SolanaSignedTransaction = Static<typeof SolanaSignedTransaction>;
+export declare const SolanaSignedTransaction: import("@sinclair/typebox").TObject<{
+    signature: import("@sinclair/typebox").TString;
+}>;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/api/solana/index.js

@@ -1,3 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaSignedTransaction = exports.SolanaSignTransaction = exports.SolanaTxAdditionalInfo = exports.SolanaTxTokenAccountInfo = exports.SolanaPublicKey = void 0;
+const params_1 = require("../../params");
+const schema_utils_1 = require("@trezor/schema-utils");
+exports.SolanaPublicKey = schema_utils_1.Type.Intersect([
+    params_1.PublicKey,
+    schema_utils_1.Type.Object({
+        publicKey: schema_utils_1.Type.String(),
+    }),
+]);
+exports.SolanaTxTokenAccountInfo = schema_utils_1.Type.Object({
+    baseAddress: schema_utils_1.Type.String(),
+    tokenProgram: schema_utils_1.Type.String(),
+    tokenMint: schema_utils_1.Type.String(),
+    tokenAccount: schema_utils_1.Type.String(),
+});
+exports.SolanaTxAdditionalInfo = schema_utils_1.Type.Object({
+    tokenAccountsInfos: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.SolanaTxTokenAccountInfo, { minItems: 1 })),
+});
+exports.SolanaSignTransaction = schema_utils_1.Type.Object({
+    path: schema_utils_1.Type.Union([schema_utils_1.Type.String(), schema_utils_1.Type.Array(schema_utils_1.Type.Number())]),
+    serializedTx: schema_utils_1.Type.String(),
+    additionalInfo: schema_utils_1.Type.Optional(exports.SolanaTxAdditionalInfo),
+});
+exports.SolanaSignedTransaction = schema_utils_1.Type.Object({
+    signature: schema_utils_1.Type.String(),
+});
 //# sourceMappingURL=index.js.map