@trezor/connect 9.5.0-beta.1 → 9.5.1-beta.1

package/lib/device/DeviceList.js

@@ -6,9 +6,9 @@ const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const Device_1 = require("./Device");
-const transportInfo_1 = require("../data/transportInfo");
 const types_1 = require("../types");
-const utils_2 = require("../types/utils");
+const TransportList_1 = require("./TransportList");
+const TransportManager_1 = require("./TransportManager");
 const debug_1 = require("../utils/debug");
 const createAuthPenaltyManager = (priority) => {
     const penalizedDevices = {};
@@ -67,100 +67,42 @@ const assertDeviceListConnected = deviceList => {
 };
 exports.assertDeviceListConnected = assertDeviceListConnected;
 class DeviceList extends utils_1.TypedEmitter {
-    transport = {};
+    transportManagers = {};
     transports = [];
     devices = createDeviceCollection();
     deviceCounter = Date.now();
     handshakeLock;
     authPenaltyManager;
-    transportCommonArgs;
+    updateTransports;
+    getConnectedTransports() {
+        return Object.values(this.transportManagers)
+            .map(manager => manager.get())
+            .filter(utils_1.isNotUndefined);
+    }
     isConnected() {
-        return !!Object.keys(this.transport).length;
+        return !!this.getConnectedTransports().length;
     }
     pendingConnection() {
-        const pending = Object.values(this.locks)
-            .map(({ promise }) => promise)
+        const pending = Object.values(this.transportManagers)
+            .map(manager => manager.pending())
             .filter(utils_1.isNotUndefined);
         if (pending.length)
             return Promise.all(pending).then(() => { });
     }
     getActiveTransports() {
-        return Object.values(this.transport).map(getTransportInfo);
-    }
-    locks = {};
-    async transportLock(apiType, abortMessage, action) {
-        const lock = this.locks[apiType] ?? (this.locks[apiType] = { sequence: 0 });
-        lock.abortMessage = abortMessage;
-        const sequence = ++lock.sequence;
-        while (lock.promise) {
-            lock.abort?.abort(new Error(abortMessage));
-            await lock.promise.catch(() => { });
-        }
-        if (sequence !== lock.sequence)
-            return Promise.reject(new Error(lock.abortMessage));
-        lock.abort = new AbortController();
-        lock.promise = action(lock.abort.signal).finally(() => {
-            delete lock.abort;
-            delete lock.promise;
-        });
-        return lock.promise;
+        return this.getConnectedTransports().map(getTransportInfo);
     }
-    scheduledUpgradeChecks = {};
     constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }) {
         super();
         const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
         this.handshakeLock = (0, utils_1.getSynchronize)();
         this.authPenaltyManager = createAuthPenaltyManager(priority);
-        this.transportCommonArgs = {
+        this.updateTransports = (0, TransportList_1.createTransportList)({
             messages,
             logger: transportLogger,
             sessionsBackgroundUrl: _sessionsBackgroundUrl,
             id: manifest?.appUrl || 'unknown app',
-        };
-    }
-    tryGetTransport(name) {
-        return this.transports.find(t => t.name === name);
-    }
-    getOrCreateTransport(transportType) {
-        const { transportCommonArgs } = this;
-        if (typeof transportType === 'string') {
-            const existing = this.tryGetTransport(transportType);
-            if (existing)
-                return existing;
-            switch (transportType) {
-                case 'WebUsbTransport':
-                    return new transport_1.WebUsbTransport(transportCommonArgs);
-                case 'NodeUsbTransport':
-                    return new transport_1.NodeUsbTransport(transportCommonArgs);
-                case 'BridgeTransport':
-                    return new transport_1.BridgeTransport({
-                        latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
-                        ...transportCommonArgs,
-                    });
-                case 'UdpTransport':
-                    return new transport_1.UdpTransport(transportCommonArgs);
-            }
-        }
-        else if (typeof transportType === 'function' && 'prototype' in transportType) {
-            const transportInstance = new transportType(transportCommonArgs);
-            if ((0, transport_1.isTransportInstance)(transportInstance)) {
-                return this.tryGetTransport(transportInstance.name) ?? transportInstance;
-            }
-        }
-        else if ((0, transport_1.isTransportInstance)(transportType)) {
-            if (this.tryGetTransport(transportType.name)) {
-                return transportType;
-            }
-            if (!transportType.getMessage()) {
-                transportType.updateMessages(transportCommonArgs.messages);
-            }
-            return transportType;
-        }
-        throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
-    }
-    createTransports(transports) {
-        const transportTypes = transports?.length ? transports : ['BridgeTransport'];
-        return transportTypes.map(this.getOrCreateTransport.bind(this));
+        });
     }
     onDeviceConnected(descriptor, transport) {
         const id = (this.deviceCounter++).toString(16).slice(-8);
@@ -190,103 +132,41 @@ class DeviceList extends utils_1.TypedEmitter {
         const device = this.devices.get(descriptor.path, transport);
         device?.usedElsewhere();
     }
-    async init(initParams = {}) {
-        this.transports = this.createTransports(initParams.transports);
+    getOrCreateTransportManager(apiType) {
+        if (!this.transportManagers[apiType]) {
+            const manager = new TransportManager_1.TransportManager({
+                startTransport: this.startTransport.bind(this),
+                stopTransport: this.stopTransport.bind(this),
+            });
+            manager.on(transport_1.TRANSPORT.START, transport => this.emit(transport_1.TRANSPORT.START, getTransportInfo(transport)));
+            manager.on(transport_1.TRANSPORT.ERROR, error => this.emit(transport_1.TRANSPORT.ERROR, { apiType, error }));
+            this.transportManagers[apiType] = manager;
+        }
+        return this.transportManagers[apiType];
+    }
+    async init({ transports, transportReconnect, pendingTransportEvent } = {}) {
+        this.transports = this.updateTransports(this.transports, transports);
         const promises = this.transports
             .map(t => t.apiType)
-            .concat((0, utils_2.typedObjectKeys)(this.transport))
-            .concat((0, utils_2.typedObjectKeys)(this.locks))
+            .concat((0, utils_1.typedObjectKeys)(this.transportManagers))
             .filter(utils_1.arrayDistinct)
-            .map(apiType => this.transportLock(apiType, 'New init', signal => this.createInitPromise(apiType, initParams, signal)));
+            .map(apiType => this.getOrCreateTransportManager(apiType).init({
+            transports: this.transports.filter(t => t.apiType === apiType),
+            transportReconnect,
+            pendingTransportEvent,
+        }));
         await Promise.all(promises);
     }
-    async createInitPromise(apiType, initParams, abortSignal) {
+    async startTransport(transport, pendingTransportEvent, signal) {
         try {
-            const transports = this.transports.filter(t => t.apiType === apiType);
-            const transport = transports.length
-                ? await this.selectTransport(transports, abortSignal)
-                : undefined;
-            const oldTransport = this.transport[apiType];
-            if (oldTransport !== transport) {
-                if (oldTransport) {
-                    delete this.transport[apiType];
-                    await this.stopTransport(oldTransport);
-                    if (!transport) {
-                        this.emit(transport_1.TRANSPORT.ERROR, { apiType, error: 'Transport disabled' });
-                    }
-                }
-                if (transport) {
-                    try {
-                        await this.initializeTransport(transport, initParams, abortSignal);
-                    }
-                    catch (error) {
-                        await this.stopTransport(transport);
-                        throw error;
-                    }
-                    transport.on(transport_1.TRANSPORT.ERROR, error => {
-                        this.emit(transport_1.TRANSPORT.ERROR, { apiType, error });
-                        this.transportLock(apiType, 'Transport error', async (signal) => {
-                            delete this.transport[apiType];
-                            await this.stopTransport(transport);
-                            if (initParams.transportReconnect) {
-                                await this.createReconnectDelay(signal);
-                                await this.createInitPromise(apiType, initParams, signal);
-                            }
-                        }).catch(() => { });
-                    });
-                    this.transport[apiType] = transport;
-                    this.emit(transport_1.TRANSPORT.START, getTransportInfo(transport));
-                }
-            }
-            if (transport && transport !== transports[0]) {
-                this.scheduleUpgradeCheck(apiType, initParams);
-            }
+            await this.initializeTransport(transport, pendingTransportEvent, signal);
         }
-        catch (error) {
-            this.emit(transport_1.TRANSPORT.ERROR, { apiType, error: error?.message });
-            if (initParams.transportReconnect && !abortSignal.aborted) {
-                this.transportLock(apiType, 'Reconnecting', async (signal) => {
-                    await this.createReconnectDelay(signal);
-                    await this.createInitPromise(apiType, initParams, signal);
-                }).catch(() => { });
-            }
+        catch (err) {
+            await this.stopTransport(transport);
+            throw err;
         }
     }
-    createReconnectDelay(signal) {
-        return (0, utils_1.resolveAfter)(1000, signal);
-    }
-    scheduleUpgradeCheck(apiType, initParams) {
-        clearTimeout(this.scheduledUpgradeChecks[apiType]);
-        this.scheduledUpgradeChecks[apiType] = setTimeout(async () => {
-            const transport = this.transport[apiType];
-            const transports = this.transports.filter(t => t.apiType === apiType);
-            if (!transport || transport === transports[0])
-                return;
-            for (const t of transports) {
-                if (t === transport)
-                    break;
-                if (await t.ping()) {
-                    this.transportLock(apiType, 'Upgrading', signal => this.createInitPromise(apiType, initParams, signal)).catch(() => { });
-                    return;
-                }
-            }
-            this.scheduleUpgradeCheck(apiType, initParams);
-        }, 1000);
-    }
-    async selectTransport([transport, ...rest], signal) {
-        if (signal.aborted)
-            throw new Error(signal.reason);
-        if (transport === this.transport[transport.apiType])
-            return transport;
-        const result = await transport.init({ signal });
-        if (result.success)
-            return transport;
-        else if (rest.length)
-            return this.selectTransport(rest, signal);
-        else
-            throw new Error(result.error);
-    }
-    async initializeTransport(transport, initParams, signal) {
+    async initializeTransport(transport, pendingTransportEvent, signal) {
         transport.on(transport_1.TRANSPORT.DEVICE_CONNECTED, d => this.onDeviceConnected(d, transport));
         transport.on(transport_1.TRANSPORT.DEVICE_DISCONNECTED, d => this.onDeviceDisconnected(d, transport));
         transport.on(transport_1.TRANSPORT.DEVICE_SESSION_CHANGED, d => this.onDeviceSessionChanged(d, transport));
@@ -296,7 +176,7 @@ class DeviceList extends utils_1.TypedEmitter {
             throw new Error(enumerateResult.error);
         }
         const descriptors = enumerateResult.payload;
-        const waitForDevicesPromise = initParams.pendingTransportEvent && descriptors.length
+        const waitForDevicesPromise = pendingTransportEvent && descriptors.length
             ? this.waitForDevices(transport, descriptors, signal)
             : Promise.resolve();
         transport.handleDescriptorsChange(descriptors);
@@ -348,20 +228,10 @@ class DeviceList extends utils_1.TypedEmitter {
     }
     async dispose() {
         this.removeAllListeners();
-        const promises = (0, utils_2.typedObjectKeys)(this.transport)
-            .concat((0, utils_2.typedObjectKeys)(this.locks))
-            .filter(utils_1.arrayDistinct)
-            .map(apiType => this.transportLock(apiType, 'Disposing', async () => {
-            const transport = this.transport[apiType];
-            if (transport) {
-                delete this.transport[apiType];
-                await this.stopTransport(transport);
-            }
-        }));
+        const promises = Object.values(this.transportManagers).map(manager => manager.dispose());
         await Promise.all(promises);
     }
     async stopTransport(transport) {
-        clearTimeout(this.scheduledUpgradeChecks[transport.apiType]);
         const devices = this.devices.clear(transport);
         devices.forEach(device => {
             this.emit(events_1.DEVICE.DISCONNECT, device);
@@ -373,7 +243,7 @@ class DeviceList extends utils_1.TypedEmitter {
         transport?.stop();
     }
     async enumerate() {
-        const promises = Object.values(this.transport).map(async (transport) => {
+        const promises = this.getConnectedTransports().map(async (transport) => {
             const res = await transport.enumerate();
             if (!res.success) {
                 return;

package/lib/device/TransportList.d.ts

@@ -0,0 +1,9 @@
+import { BridgeTransport, NodeUsbTransport, Transport, UdpTransport } from '@trezor/transport';
+import type { AbstractTransportParams } from '@trezor/transport/lib/transports/abstract';
+import { ConnectSettingsTransport } from '../types';
+type Params = AbstractTransportParams & {
+    sessionsBackgroundUrl?: string | null;
+};
+export declare const createTransportList: (params: Params) => (existing: Transport[], transports?: ConnectSettingsTransport[]) => (Transport | NodeUsbTransport | BridgeTransport | UdpTransport)[];
+export {};
+//# sourceMappingURL=TransportList.d.ts.map

package/lib/device/TransportList.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransportList = void 0;
+const transport_1 = require("@trezor/transport");
+const constants_1 = require("../constants");
+const transportInfo_1 = require("../data/transportInfo");
+const tryGetTransport = (transports, name) => transports.find(t => t.name === name);
+const getOrCreateTransport = (transports, transportType, params) => {
+    if (typeof transportType === 'string') {
+        const existing = tryGetTransport(transports, transportType);
+        if (existing)
+            return existing;
+        switch (transportType) {
+            case 'WebUsbTransport':
+                return new transport_1.WebUsbTransport(params);
+            case 'NodeUsbTransport':
+                return new transport_1.NodeUsbTransport(params);
+            case 'BridgeTransport':
+                return new transport_1.BridgeTransport({
+                    latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
+                    ...params,
+                });
+            case 'UdpTransport':
+                return new transport_1.UdpTransport(params);
+        }
+    }
+    else if (typeof transportType === 'function' && 'prototype' in transportType) {
+        const transportInstance = new transportType(params);
+        if ((0, transport_1.isTransportInstance)(transportInstance)) {
+            return tryGetTransport(transports, transportInstance.name) ?? transportInstance;
+        }
+    }
+    else if ((0, transport_1.isTransportInstance)(transportType)) {
+        if (tryGetTransport(transports, transportType.name)) {
+            return transportType;
+        }
+        if (!transportType.getMessage()) {
+            transportType.updateMessages(params.messages);
+        }
+        return transportType;
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
+};
+const createTransports = (existing, transports = [], params) => {
+    const transportTypes = transports?.length ? transports : ['BridgeTransport'];
+    return transportTypes.map(type => getOrCreateTransport(existing, type, params));
+};
+const createTransportList = (params) => (existing, transports) => createTransports(existing, transports, params);
+exports.createTransportList = createTransportList;
+//# sourceMappingURL=TransportList.js.map

package/lib/device/TransportManager.d.ts

@@ -0,0 +1,34 @@
+import { TRANSPORT, Transport } from '@trezor/transport';
+import { TypedEmitter } from '@trezor/utils';
+type TransportManagerEvents = {
+    [TRANSPORT.START]: Transport;
+    [TRANSPORT.ERROR]: string;
+};
+type TransportManagerParams = {
+    startTransport: (transport: Transport, pendingTransportEvent: boolean, signal: AbortSignal) => Promise<void>;
+    stopTransport: (transport: Transport) => Promise<void>;
+};
+type InitParams = {
+    transports: Transport[];
+    transportReconnect?: boolean;
+    pendingTransportEvent?: boolean;
+};
+export declare class TransportManager extends TypedEmitter<TransportManagerEvents> {
+    private lock;
+    private transports;
+    private activeTransport?;
+    private transportReconnect;
+    private upgradeTimeout?;
+    private readonly startTransport;
+    private readonly stopTransport;
+    constructor({ startTransport, stopTransport }: TransportManagerParams);
+    pending(): Promise<void> | undefined;
+    get(): Transport | undefined;
+    init({ transports, transportReconnect, pendingTransportEvent }: InitParams): Promise<void>;
+    dispose(): Promise<void>;
+    private selectTransport;
+    private scheduleUpgradeCheck;
+    private createInitPromise;
+}
+export {};
+//# sourceMappingURL=TransportManager.d.ts.map

package/lib/device/TransportManager.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportManager = void 0;
+const transport_1 = require("@trezor/transport");
+const utils_1 = require("@trezor/utils");
+const createOverrideLock = () => {
+    let promise;
+    let sequence = 0;
+    let abort;
+    let message;
+    const override = async (abortMessage, action) => {
+        message = abortMessage;
+        const seq = ++sequence;
+        while (promise) {
+            abort?.abort(new Error(abortMessage));
+            await promise.catch(() => { });
+        }
+        if (seq !== sequence)
+            return Promise.reject(new Error(message));
+        abort = new AbortController();
+        promise = action(abort.signal).finally(() => {
+            abort = undefined;
+            promise = undefined;
+        });
+        return promise;
+    };
+    const getPending = () => promise;
+    return { override, getPending };
+};
+class TransportManager extends utils_1.TypedEmitter {
+    lock = createOverrideLock();
+    transports = [];
+    activeTransport;
+    transportReconnect = false;
+    upgradeTimeout;
+    startTransport;
+    stopTransport;
+    constructor({ startTransport, stopTransport }) {
+        super();
+        this.startTransport = startTransport;
+        this.stopTransport = stopTransport;
+    }
+    pending() {
+        return this.lock.getPending();
+    }
+    get() {
+        return this.activeTransport;
+    }
+    init({ transports, transportReconnect = false, pendingTransportEvent = false }) {
+        this.transports = transports;
+        this.transportReconnect = transportReconnect;
+        return this.lock.override('New init', signal => this.createInitPromise(pendingTransportEvent, signal));
+    }
+    dispose() {
+        this.removeAllListeners();
+        return this.lock.override('Disposing', async () => {
+            const { activeTransport } = this;
+            if (activeTransport) {
+                clearTimeout(this.upgradeTimeout);
+                delete this.activeTransport;
+                await this.stopTransport(activeTransport);
+            }
+        });
+    }
+    async selectTransport([transport, ...rest], signal) {
+        if (signal.aborted)
+            throw new Error(signal.reason);
+        if (transport === this.activeTransport)
+            return transport;
+        const result = await transport.init({ signal });
+        if (result.success)
+            return transport;
+        else if (rest.length)
+            return this.selectTransport(rest, signal);
+        else
+            throw new Error(result.error);
+    }
+    scheduleUpgradeCheck(pendingTransportEvent) {
+        clearTimeout(this.upgradeTimeout);
+        this.upgradeTimeout = setTimeout(async () => {
+            if (!this.activeTransport || this.activeTransport === this.transports[0])
+                return;
+            for (const t of this.transports) {
+                if (t === this.activeTransport)
+                    break;
+                if (await t.ping()) {
+                    this.lock
+                        .override('Upgrading', signal => this.createInitPromise(pendingTransportEvent, signal))
+                        .catch(() => { });
+                    return;
+                }
+            }
+            this.scheduleUpgradeCheck(pendingTransportEvent);
+        }, 1000);
+    }
+    async createInitPromise(pendingTransportEvent, abortSignal) {
+        try {
+            const { transports, activeTransport } = this;
+            const transport = transports.length
+                ? await this.selectTransport(transports, abortSignal)
+                : undefined;
+            if (activeTransport !== transport) {
+                if (activeTransport) {
+                    clearTimeout(this.upgradeTimeout);
+                    delete this.activeTransport;
+                    await this.stopTransport(activeTransport);
+                }
+                if (transport) {
+                    await this.startTransport(transport, pendingTransportEvent, abortSignal);
+                    transport.on(transport_1.TRANSPORT.ERROR, error => {
+                        this.emit(transport_1.TRANSPORT.ERROR, error);
+                        clearTimeout(this.upgradeTimeout);
+                        this.lock
+                            .override('Transport error', async (signal) => {
+                            delete this.activeTransport;
+                            await this.stopTransport(transport);
+                            if (this.transportReconnect) {
+                                await (0, utils_1.resolveAfter)(1000, signal);
+                                await this.createInitPromise(pendingTransportEvent, signal);
+                            }
+                        })
+                            .catch(() => { });
+                    });
+                    this.activeTransport = transport;
+                    this.emit(transport_1.TRANSPORT.START, transport);
+                }
+                else {
+                    this.emit(transport_1.TRANSPORT.ERROR, 'Transport disabled');
+                }
+            }
+            if (transport && transport !== transports[0]) {
+                this.scheduleUpgradeCheck(pendingTransportEvent);
+            }
+        }
+        catch (error) {
+            this.emit(transport_1.TRANSPORT.ERROR, error?.message);
+            if (this.transportReconnect && !abortSignal.aborted) {
+                this.lock
+                    .override('Reconnecting', async (signal) => {
+                    await (0, utils_1.resolveAfter)(1000, signal);
+                    await this.createInitPromise(pendingTransportEvent, signal);
+                })
+                    .catch(() => { });
+            }
+        }
+    }
+}
+exports.TransportManager = TransportManager;
+//# sourceMappingURL=TransportManager.js.map

package/lib/device/checkFirmwareRevision.js

@@ -4,12 +4,14 @@ exports.checkFirmwareRevision = void 0;
 const versionUtils_1 = require("@trezor/utils/lib/versionUtils");
 const downloadReleasesMetadata_1 = require("../data/downloadReleasesMetadata");
 const calculateRevisionForDevice_1 = require("./calculateRevisionForDevice");
-const isNodeJSNetworkError = (e) => ['FetchError', 'AbortError'].includes(e.name);
-const isReactNativeNetworkError = (e) => e.name === 'TypeError' && e.message.includes('Network request failed');
-const isNetworkError = (e) => {
+const assets_browser_1 = require("../utils/assets-browser");
+const isNotFoundError = (e) => e instanceof assets_browser_1.HttpRequestError && e.response.status === 404;
+const isNodeJSOfflineError = (e) => ['FetchError', 'AbortError'].includes(e.name);
+const isReactNativeOfflineError = (e) => e.name === 'TypeError' && e.message.includes('Network request failed');
+const isOfflineError = (e) => {
     if (!(e instanceof Error))
         return false;
-    return isNodeJSNetworkError(e) || isReactNativeNetworkError(e);
+    return isNodeJSOfflineError(e) || isReactNativeOfflineError(e);
 };
 const getOnlineReleaseMetadata = async ({ firmwareVersion, internalModel, }) => {
     const onlineReleases = await (0, downloadReleasesMetadata_1.downloadReleasesMetadata)({ internal_model: internalModel });
@@ -49,7 +51,9 @@ const checkFirmwareRevision = async ({ firmwareVersion, internalModel, deviceRev
             return { success: true };
         }
         catch (e) {
-            return isNetworkError(e)
+            if (isNotFoundError(e))
+                return failFirmwareRevisionCheck('firmware-version-unknown');
+            return isOfflineError(e)
                 ? failFirmwareRevisionCheck('cannot-perform-check-offline')
                 : failFirmwareRevisionCheck('other-error');
         }

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

@@ -71,8 +71,7 @@ export type SolanaComposedTransaction = Static<typeof SolanaComposedTransaction>
 export declare const SolanaComposedTransaction: import("@trezor/schema-utils").TObject<{
     serializedTx: import("@trezor/schema-utils").TString;
     additionalInfo: import("@trezor/schema-utils").TObject<{
-        isCreatingAccount: import("@trezor/schema-utils").TBoolean;
-        newTokenAccountProgramName: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"spl-token">, import("@trezor/schema-utils").TLiteral<"spl-token-2022">]>>;
+        newAccountProgramName: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"spl-token">, import("@trezor/schema-utils").TLiteral<"spl-token-2022">]>>;
         tokenAccountInfo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
             baseAddress: import("@trezor/schema-utils").TString;
             tokenProgram: import("@trezor/schema-utils").TString;

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

@@ -51,8 +51,7 @@ exports.SolanaComposeTransaction = schema_utils_1.Type.Object({
 exports.SolanaComposedTransaction = schema_utils_1.Type.Object({
     serializedTx: schema_utils_1.Type.String(),
     additionalInfo: schema_utils_1.Type.Object({
-        isCreatingAccount: schema_utils_1.Type.Boolean(),
-        newTokenAccountProgramName: schema_utils_1.Type.Optional(exports.SolanaProgramName),
+        newAccountProgramName: schema_utils_1.Type.Optional(exports.SolanaProgramName),
         tokenAccountInfo: schema_utils_1.Type.Optional(exports.SolanaTxTokenAccountInfo),
     }),
 });