@injectivelabs/wallet-trezor 1.15.0 → 1.15.2

package/dist/cjs/utils.d.ts

@@ -0,0 +1,16 @@
+import { type TypedMessageV4 } from '@injectivelabs/sdk-ts';
+/**
+ * Calculates the domain_separator_hash and message_hash from an EIP-712 Typed Data object.
+ *
+ * The Trezor Model 1 does not currently support constructing the hash on the device,
+ * so this function pre-computes them.
+ *
+ * @template {TypedMessage} T
+ * @param {T} data - The EIP-712 Typed Data object.
+ * @param {boolean} metamask_v4_compat - Set to `true` for compatibility with Metamask's signTypedData_v4 function.
+ * @returns {{domain_separator_hash: string, message_hash?: string} & T} The hashes.
+ */
+export declare const transformTypedData: <T extends TypedMessageV4>(data: T, metamask_v4_compat?: boolean) => {
+    domain_separator_hash: string;
+    message_hash?: string;
+} & T;

package/dist/cjs/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTypedData = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const sdk_ts_1 = require("@injectivelabs/sdk-ts");
+/**
+ * Calculates the domain_separator_hash and message_hash from an EIP-712 Typed Data object.
+ *
+ * The Trezor Model 1 does not currently support constructing the hash on the device,
+ * so this function pre-computes them.
+ *
+ * @template {TypedMessage} T
+ * @param {T} data - The EIP-712 Typed Data object.
+ * @param {boolean} metamask_v4_compat - Set to `true` for compatibility with Metamask's signTypedData_v4 function.
+ * @returns {{domain_separator_hash: string, message_hash?: string} & T} The hashes.
+ */
+const transformTypedData = (data, metamask_v4_compat = true) => {
+    if (!metamask_v4_compat) {
+        throw new exceptions_1.TrezorException(new Error('Trezor: Only version 4 of typed data signing is supported'));
+    }
+    const version = sdk_ts_1.SignTypedDataVersionV4;
+    const { types, primaryType, domain, message } = (0, sdk_ts_1.TypedDataUtilsSanitizeData)(data);
+    const domainSeparatorHash = (0, sdk_ts_1.TypedDataUtilsHashStruct)('EIP712Domain', (0, sdk_ts_1.sanitizeTypedData)(domain), types, version).toString('hex');
+    let messageHash = null;
+    if (primaryType !== 'EIP712Domain') {
+        messageHash = (0, sdk_ts_1.TypedDataUtilsHashStruct)(primaryType, (0, sdk_ts_1.sanitizeTypedData)(message), types, version).toString('hex');
+    }
+    return {
+        domain_separator_hash: domainSeparatorHash,
+        message_hash: messageHash,
+        ...data,
+    };
+};
+exports.transformTypedData = transformTypedData;

package/dist/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { TrezorBip32 as TrezorBip32Strategy } from './strategy/TrezorBip32.js';
+export { TrezorBip44 as TrezorBip44Strategy } from './strategy/TrezorBip44.js';
+export * from './types.js';

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export { TrezorBip32 as TrezorBip32Strategy } from './strategy/TrezorBip32.js';
+export { TrezorBip44 as TrezorBip44Strategy } from './strategy/TrezorBip44.js';
+export * from './types.js';

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/esm/strategy/Base.d.ts

@@ -0,0 +1,42 @@
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { TxRaw, TxResponse, DirectSignResponse, AminoSignResponse } from '@injectivelabs/sdk-ts';
+import { StdSignDoc, WalletDeviceType, BaseConcreteStrategy, ConcreteWalletStrategy, SendTransactionOptions, ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import { TrezorDerivationPathType } from '../types.js';
+export default class TrezorBase extends BaseConcreteStrategy implements ConcreteWalletStrategy {
+    private baseDerivationPath;
+    private trezor;
+    private ethereumOptions;
+    private alchemy;
+    private derivationPathType;
+    constructor(args: ConcreteEthereumWalletStrategyArgs & {
+        derivationPathType: TrezorDerivationPathType;
+    });
+    getWalletDeviceType(): Promise<WalletDeviceType>;
+    enable(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getAddresses(): Promise<string[]>;
+    getSessionOrConfirm(address: AccountAddress): Promise<string>;
+    sendEthereumTransaction(txData: any, options: {
+        address: string;
+        ethereumChainId: EthereumChainId;
+    }): Promise<string>;
+    sendTransaction(transaction: TxRaw, options: SendTransactionOptions): Promise<TxResponse>;
+    signEip712TypedData(eip712json: string, address: AccountAddress): Promise<string>;
+    signAminoCosmosTransaction(_transaction: {
+        address: string;
+        signDoc: StdSignDoc;
+    }): Promise<AminoSignResponse>;
+    signCosmosTransaction(_transaction: {
+        txRaw: TxRaw;
+        accountNumber: number;
+        chainId: string;
+        address: string;
+    }): Promise<DirectSignResponse>;
+    signArbitrary(signer: AccountAddress, data: string | Uint8Array): Promise<string>;
+    getEthereumChainId(): Promise<string>;
+    getEthereumTransactionReceipt(txHash: string): Promise<string>;
+    getPubKey(): Promise<string>;
+    private signEthereumTransaction;
+    private getWalletForAddress;
+    private getAlchemy;
+}

package/dist/esm/strategy/Base.js

@@ -0,0 +1,277 @@
+/* eslint-disable camelcase */
+/* eslint-disable class-methods-use-this */
+import { EthereumChainId } from '@injectivelabs/ts-types';
+import { Alchemy, Network as AlchemyNetwork } from 'alchemy-sdk';
+import { addHexPrefix } from 'ethereumjs-util';
+import { FeeMarketEIP1559Transaction } from '@ethereumjs/tx';
+import { Common, Chain, Hardfork } from '@ethereumjs/common';
+import { TrezorConnect } from '@bangjelkoski/trezor-connect-web';
+import { ErrorType, WalletException, TrezorException, GeneralException, TransactionException, UnspecifiedErrorCode, } from '@injectivelabs/exceptions';
+import { toUtf8, TxGrpcApi, } from '@injectivelabs/sdk-ts';
+import { TIP_IN_GWEI, WalletAction, getKeyFromRpcUrl, WalletDeviceType, BaseConcreteStrategy, DEFAULT_BASE_DERIVATION_PATH, DEFAULT_ADDRESS_SEARCH_LIMIT, DEFAULT_NUM_ADDRESSES_TO_FETCH, } from '@injectivelabs/wallet-base';
+import { TrezorTransportInit } from './hw/index.js';
+import { transformTypedData } from '../utils.js';
+const getNetworkFromChainId = (chainId) => {
+    if (chainId === EthereumChainId.Goerli) {
+        return Chain.Goerli;
+    }
+    if (chainId === EthereumChainId.Sepolia) {
+        return Chain.Sepolia;
+    }
+    if (chainId === EthereumChainId.Kovan) {
+        return Chain.Goerli;
+    }
+    return Chain.Mainnet;
+};
+export default class TrezorBase extends BaseConcreteStrategy {
+    baseDerivationPath;
+    trezor;
+    ethereumOptions;
+    alchemy;
+    derivationPathType;
+    constructor(args) {
+        super(args);
+        this.baseDerivationPath = DEFAULT_BASE_DERIVATION_PATH;
+        this.derivationPathType = args.derivationPathType;
+        this.trezor = new TrezorTransportInit();
+        this.ethereumOptions = args.ethereumOptions;
+    }
+    async getWalletDeviceType() {
+        return Promise.resolve(WalletDeviceType.Hardware);
+    }
+    async enable() {
+        return Promise.resolve(true);
+    }
+    async disconnect() {
+        return Promise.resolve();
+    }
+    async getAddresses() {
+        const { baseDerivationPath, derivationPathType } = this;
+        try {
+            await this.trezor.connect();
+            const accountManager = await this.trezor.getAccountManager();
+            const wallets = await accountManager.getWallets(baseDerivationPath, derivationPathType);
+            return wallets.map((k) => k.address);
+        }
+        catch (e) {
+            throw new TrezorException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.GetAccounts,
+            });
+        }
+    }
+    async getSessionOrConfirm(address) {
+        return Promise.resolve(`0x${Buffer.from(`Confirmation for ${address} at time: ${Date.now()}`).toString('hex')}`);
+    }
+    async sendEthereumTransaction(txData, options) {
+        const signedTransaction = await this.signEthereumTransaction(txData, options);
+        try {
+            const alchemy = await this.getAlchemy();
+            const txReceipt = await alchemy.core.sendTransaction(addHexPrefix(signedTransaction.serialize().toString('hex')));
+            return txReceipt.hash;
+        }
+        catch (e) {
+            throw new TrezorException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SendEthereumTransaction,
+            });
+        }
+    }
+    async sendTransaction(transaction, options) {
+        const { endpoints, txTimeout } = options;
+        if (!endpoints) {
+            throw new WalletException(new Error('You have to pass endpoints.grpc within the options for using Ethereum native wallets'));
+        }
+        const txApi = new TxGrpcApi(endpoints.grpc);
+        const response = await txApi.broadcast(transaction, { txTimeout });
+        if (response.code !== 0) {
+            throw new TransactionException(new Error(response.rawLog), {
+                code: UnspecifiedErrorCode,
+                contextCode: response.code,
+                contextModule: response.codespace,
+            });
+        }
+        return response;
+    }
+    async signEip712TypedData(eip712json, address) {
+        const object = JSON.parse(eip712json);
+        const compatibleObject = {
+            ...object,
+            domain: {
+                ...object.domain,
+                chainId: object.domain.chainId,
+                salt: '0',
+            },
+        };
+        const dataWithHashes = transformTypedData(compatibleObject);
+        const { types: { EIP712Domain = [], ...otherTypes } = {}, message = {}, domain = {}, primaryType, domain_separator_hash, message_hash, } = dataWithHashes;
+        try {
+            await this.trezor.connect();
+            const { derivationPath } = await this.getWalletForAddress(address);
+            const response = await TrezorConnect.ethereumSignTypedData({
+                path: derivationPath,
+                data: {
+                    types: { EIP712Domain, ...otherTypes },
+                    message,
+                    domain,
+                    primaryType,
+                },
+                message_hash,
+                domain_separator_hash,
+                metamask_v4_compat: true,
+            });
+            if (!response.success) {
+                // noinspection ExceptionCaughtLocallyJS
+                throw new Error((response.payload && response.payload.error) || 'Unknown error');
+            }
+            return response.payload.signature;
+        }
+        catch (e) {
+            throw new TrezorException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignTransaction,
+            });
+        }
+    }
+    async signAminoCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SendTransaction,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async signCosmosTransaction(_transaction) {
+        throw new WalletException(new Error('This wallet does not support signing Cosmos transactions'), {
+            code: UnspecifiedErrorCode,
+            type: ErrorType.WalletError,
+            contextModule: WalletAction.SendTransaction,
+        });
+    }
+    async signArbitrary(signer, data) {
+        try {
+            await this.trezor.connect();
+            const { derivationPath } = await this.getWalletForAddress(signer);
+            const response = await TrezorConnect.ethereumSignMessage({
+                path: derivationPath,
+                message: toUtf8(data),
+            });
+            if (!response.success) {
+                throw new Error((response.payload && response.payload.error) || 'Unknown error');
+            }
+            return response.payload.signature;
+        }
+        catch (e) {
+            throw new TrezorException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignTransaction,
+            });
+        }
+    }
+    async getEthereumChainId() {
+        const alchemy = await this.getAlchemy();
+        const alchemyProvider = await alchemy.config.getProvider();
+        return alchemyProvider.network.chainId.toString();
+    }
+    async getEthereumTransactionReceipt(txHash) {
+        return Promise.resolve(txHash);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async getPubKey() {
+        throw new WalletException(new Error('You can only fetch PubKey from Cosmos native wallets'));
+    }
+    async signEthereumTransaction(txData, options) {
+        const chainId = parseInt(options.ethereumChainId.toString(), 10);
+        const alchemy = await this.getAlchemy();
+        const nonce = await alchemy.core.getTransactionCount(options.address);
+        const common = new Common({
+            chain: getNetworkFromChainId(chainId),
+            hardfork: Hardfork.London,
+        });
+        const eip1559TxData = {
+            from: txData.from,
+            data: txData.data,
+            to: txData.to,
+            nonce: addHexPrefix(nonce.toString(16)),
+            gas: addHexPrefix(txData.gas),
+            gasLimit: addHexPrefix(txData.gas),
+            maxFeePerGas: addHexPrefix(txData.gasPrice || txData.maxFeePerGas),
+            maxPriorityFeePerGas: addHexPrefix(txData.maxPriorityFeePerGas || TIP_IN_GWEI.toString(16)),
+        };
+        const tx = FeeMarketEIP1559Transaction.fromTxData(eip1559TxData, {
+            common,
+        });
+        const transaction = {
+            ...tx.toJSON(),
+            chainId,
+        };
+        try {
+            await this.trezor.connect();
+            const { derivationPath } = await this.getWalletForAddress(options.address);
+            const response = await TrezorConnect.ethereumSignTransaction({
+                path: derivationPath,
+                transaction,
+            });
+            if (!response.success) {
+                throw new TrezorException(new Error((response.payload && response.payload.error) ||
+                    'Something happened while signing with Trezor'), {
+                    code: UnspecifiedErrorCode,
+                    type: ErrorType.WalletError,
+                    contextModule: WalletAction.SignEthereumTransaction,
+                });
+            }
+            const signedTxData = {
+                ...eip1559TxData,
+                v: `${response.payload.v}`,
+                r: `${response.payload.r}`,
+                s: `${response.payload.s}`,
+            };
+            return FeeMarketEIP1559Transaction.fromTxData(signedTxData, {
+                common,
+            });
+        }
+        catch (e) {
+            if (e instanceof TrezorException) {
+                throw e;
+            }
+            throw new TrezorException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: WalletAction.SignEthereumTransaction,
+            });
+        }
+    }
+    async getWalletForAddress(address) {
+        const { baseDerivationPath, derivationPathType } = this;
+        const accountManager = await this.trezor.getAccountManager();
+        if (!accountManager.hasWalletForAddress(address)) {
+            for (let i = 0; i < DEFAULT_ADDRESS_SEARCH_LIMIT / DEFAULT_NUM_ADDRESSES_TO_FETCH; i += 1) {
+                await accountManager.getWallets(baseDerivationPath, derivationPathType);
+                if (accountManager.hasWalletForAddress(address)) {
+                    return (await accountManager.getWalletForAddress(address));
+                }
+            }
+        }
+        return (await accountManager.getWalletForAddress(address));
+    }
+    async getAlchemy() {
+        if (this.alchemy) {
+            return this.alchemy;
+        }
+        const { rpcUrl, ethereumChainId } = this.ethereumOptions;
+        if (!rpcUrl) {
+            throw new GeneralException(new Error('Please pass rpcUrl within the ethereumOptions'));
+        }
+        this.alchemy = new Alchemy({
+            apiKey: getKeyFromRpcUrl(rpcUrl),
+            network: ethereumChainId === EthereumChainId.Mainnet
+                ? AlchemyNetwork.ETH_MAINNET
+                : AlchemyNetwork.ETH_SEPOLIA,
+        });
+        return this.alchemy;
+    }
+}

package/dist/esm/strategy/TrezorBip32.d.ts

@@ -0,0 +1,5 @@
+import { ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import TrezorBase from './Base.js';
+export declare class TrezorBip32 extends TrezorBase {
+    constructor(args: ConcreteEthereumWalletStrategyArgs);
+}

package/dist/esm/strategy/TrezorBip32.js

@@ -0,0 +1,10 @@
+import { TrezorDerivationPathType } from '../types.js';
+import TrezorBase from './Base.js';
+export class TrezorBip32 extends TrezorBase {
+    constructor(args) {
+        super({
+            ...args,
+            derivationPathType: TrezorDerivationPathType.Bip32,
+        });
+    }
+}

package/dist/esm/strategy/TrezorBip44.d.ts

@@ -0,0 +1,5 @@
+import { ConcreteEthereumWalletStrategyArgs } from '@injectivelabs/wallet-base';
+import TrezorBase from './Base.js';
+export declare class TrezorBip44 extends TrezorBase {
+    constructor(args: ConcreteEthereumWalletStrategyArgs);
+}

package/dist/esm/strategy/TrezorBip44.js

@@ -0,0 +1,10 @@
+import { TrezorDerivationPathType } from '../types.js';
+import TrezorBase from './Base.js';
+export class TrezorBip44 extends TrezorBase {
+    constructor(args) {
+        super({
+            ...args,
+            derivationPathType: TrezorDerivationPathType.Bip44,
+        });
+    }
+}

package/dist/esm/strategy/hw/AccountManager.d.ts

@@ -0,0 +1,19 @@
+import { AccountAddress } from '@injectivelabs/ts-types';
+import { TrezorWalletInfo, TrezorDerivationPathType } from '../../types.js';
+export default class AccountManager {
+    private wallets;
+    constructor();
+    getWallets(baseDerivationPath: string, derivationPathType: TrezorDerivationPathType): Promise<TrezorWalletInfo[]>;
+    getTrezorDerivationPathBasedOnType: ({ fullBaseDerivationPath, derivationPathType, index, }: {
+        fullBaseDerivationPath: string;
+        derivationPathType: TrezorDerivationPathType;
+        index: number;
+    }) => string;
+    private getWalletsBasedOnIndex;
+    private hasWallets;
+    private hasWalletsInOffset;
+    private getOffset;
+    hasWalletForAddress(address: AccountAddress): boolean;
+    getWalletForAddress(address: AccountAddress): Promise<TrezorWalletInfo | undefined>;
+    reset(): void;
+}

package/dist/esm/strategy/hw/AccountManager.js

@@ -0,0 +1,100 @@
+import HDNode from 'hdkey';
+import { TrezorException } from '@injectivelabs/exceptions';
+import { TrezorDerivationPathType } from '../../types.js';
+import { addHexPrefix, publicKeyToAddress } from '@injectivelabs/sdk-ts';
+import { DEFAULT_NUM_ADDRESSES_TO_FETCH } from '@injectivelabs/wallet-base';
+import { TrezorConnect } from '@bangjelkoski/trezor-connect-web';
+const addressOfHDKey = (hdKey) => {
+    const shouldSanitizePublicKey = true;
+    const derivedPublicKey = hdKey.publicKey;
+    const ethereumAddressWithoutPrefix = Buffer.from(publicKeyToAddress(derivedPublicKey, shouldSanitizePublicKey)).toString('hex');
+    const address = addHexPrefix(ethereumAddressWithoutPrefix);
+    return address;
+};
+export default class AccountManager {
+    wallets = [];
+    constructor() {
+        this.wallets = [];
+    }
+    async getWallets(baseDerivationPath, derivationPathType) {
+        const { start, end } = this.getOffset();
+        /**
+         * 1. Wallets are not yet fetched at all,
+         * 2. Wallets are not yet fetched for that offset
+         */
+        if (!this.hasWallets() || !this.hasWalletsInOffset(start)) {
+            await this.getWalletsBasedOnIndex({
+                start,
+                end,
+                baseDerivationPath,
+                derivationPathType,
+            });
+        }
+        return this.wallets.slice(start, end);
+    }
+    getTrezorDerivationPathBasedOnType = ({ fullBaseDerivationPath, derivationPathType, index, }) => {
+        if (derivationPathType === TrezorDerivationPathType.Bip44) {
+            return `${fullBaseDerivationPath}/${index}'/0/0`;
+        }
+        if (derivationPathType === TrezorDerivationPathType.Legacy) {
+            return `m/${index}`;
+        }
+        return `${fullBaseDerivationPath}/0'/0/${index}`;
+    };
+    async getWalletsBasedOnIndex({ start, end, baseDerivationPath, derivationPathType, }) {
+        const pathsToFetch = [];
+        for (let index = start; index < end; index += 1) {
+            const path = this.getTrezorDerivationPathBasedOnType({
+                fullBaseDerivationPath: baseDerivationPath,
+                derivationPathType,
+                index,
+            });
+            pathsToFetch.push({
+                path,
+                showOnTrezor: false,
+            });
+        }
+        const result = await TrezorConnect.ethereumGetPublicKey({
+            bundle: pathsToFetch,
+        });
+        if (!result.success) {
+            throw new TrezorException(new Error((result.payload && result.payload.error) ||
+                'Please make sure your Trezor is connected and unlocked'));
+        }
+        for (const item of result.payload) {
+            const hdKey = new HDNode();
+            hdKey.publicKey = Buffer.from(item.publicKey, 'hex');
+            hdKey.chainCode = Buffer.from(item.chainCode, 'hex');
+            const address = addressOfHDKey(hdKey);
+            this.wallets.push({
+                hdKey,
+                derivationPath: item.serializedPath,
+                address: address.toLowerCase(),
+            });
+        }
+    }
+    hasWallets() {
+        return this.wallets.length > 0;
+    }
+    hasWalletsInOffset(offset) {
+        return this.wallets.length > offset;
+    }
+    getOffset() {
+        const totalWallets = this.wallets.length;
+        const nextBatchStart = totalWallets;
+        const nextBatchEnd = totalWallets + DEFAULT_NUM_ADDRESSES_TO_FETCH;
+        return {
+            start: nextBatchStart,
+            end: nextBatchEnd,
+        };
+    }
+    hasWalletForAddress(address) {
+        return (this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase()) !== undefined);
+    }
+    async getWalletForAddress(address) {
+        return this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase());
+    }
+    reset() {
+        this.wallets = [];
+    }
+}

package/dist/esm/strategy/hw/index.d.ts

@@ -0,0 +1,4 @@
+import TrezorTransportInit from './transport/transport-init.js';
+import TrezorTransportNoInit from './transport/transport-no-init.js';
+import BaseTrezorTransport from './transport/base.js';
+export { TrezorTransportInit, TrezorTransportNoInit, BaseTrezorTransport };

package/dist/esm/strategy/hw/index.js

@@ -0,0 +1,4 @@
+import TrezorTransportInit from './transport/transport-init.js';
+import TrezorTransportNoInit from './transport/transport-no-init.js';
+import BaseTrezorTransport from './transport/base.js';
+export { TrezorTransportInit, TrezorTransportNoInit, BaseTrezorTransport };

package/dist/esm/strategy/hw/transport/base.d.ts

@@ -0,0 +1,6 @@
+import AccountManager from './../AccountManager.js';
+export default class BaseTrezorTransport {
+    private accountManager;
+    connect(): Promise<void>;
+    getAccountManager(): Promise<AccountManager>;
+}

package/dist/esm/strategy/hw/transport/base.js

@@ -0,0 +1,13 @@
+import AccountManager from './../AccountManager.js';
+export default class BaseTrezorTransport {
+    accountManager = null;
+    async connect() {
+        return Promise.resolve();
+    }
+    async getAccountManager() {
+        if (!this.accountManager) {
+            this.accountManager = new AccountManager();
+        }
+        return this.accountManager;
+    }
+}

package/dist/esm/strategy/hw/transport/transport-init.d.ts

@@ -0,0 +1,4 @@
+import BaseTrezorTransport from './base.js';
+export default class TrezorTransportInit extends BaseTrezorTransport {
+    constructor();
+}

package/dist/esm/strategy/hw/transport/transport-init.js

@@ -0,0 +1,21 @@
+import { TrezorConnect } from '@bangjelkoski/trezor-connect-web';
+import { WalletException } from '@injectivelabs/exceptions';
+import BaseTrezorTransport from './base.js';
+const TREZOR_CONNECT_MANIFEST = {
+    email: 'contact@injectivelabs.org',
+    appUrl: 'https://injectivelabs.org',
+};
+export default class TrezorTransportInit extends BaseTrezorTransport {
+    constructor() {
+        super();
+        try {
+            TrezorConnect.init({
+                lazyLoad: true,
+                manifest: TREZOR_CONNECT_MANIFEST,
+            });
+        }
+        catch (e) {
+            throw new WalletException(e);
+        }
+    }
+}

package/dist/esm/strategy/hw/transport/transport-no-init.d.ts

@@ -0,0 +1,4 @@
+import BaseTrezorTransport from './base.js';
+export default class TrezorTransportNoInit extends BaseTrezorTransport {
+    constructor();
+}

package/dist/esm/strategy/hw/transport/transport-no-init.js

@@ -0,0 +1,6 @@
+import BaseTrezorTransport from './base.js';
+export default class TrezorTransportNoInit extends BaseTrezorTransport {
+    constructor() {
+        super();
+    }
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,11 @@
+import type HDNode from 'hdkey';
+export declare enum TrezorDerivationPathType {
+    Bip32 = "bip32",
+    Bip44 = "bip44",
+    Legacy = "legacy"
+}
+export interface TrezorWalletInfo {
+    address: string;
+    hdKey: HDNode;
+    derivationPath: string;
+}

package/dist/esm/types.js

@@ -0,0 +1,6 @@
+export var TrezorDerivationPathType;
+(function (TrezorDerivationPathType) {
+    TrezorDerivationPathType["Bip32"] = "bip32";
+    TrezorDerivationPathType["Bip44"] = "bip44";
+    TrezorDerivationPathType["Legacy"] = "legacy";
+})(TrezorDerivationPathType || (TrezorDerivationPathType = {}));

package/dist/esm/utils.d.ts

@@ -0,0 +1,16 @@
+import { type TypedMessageV4 } from '@injectivelabs/sdk-ts';
+/**
+ * Calculates the domain_separator_hash and message_hash from an EIP-712 Typed Data object.
+ *
+ * The Trezor Model 1 does not currently support constructing the hash on the device,
+ * so this function pre-computes them.
+ *
+ * @template {TypedMessage} T
+ * @param {T} data - The EIP-712 Typed Data object.
+ * @param {boolean} metamask_v4_compat - Set to `true` for compatibility with Metamask's signTypedData_v4 function.
+ * @returns {{domain_separator_hash: string, message_hash?: string} & T} The hashes.
+ */
+export declare const transformTypedData: <T extends TypedMessageV4>(data: T, metamask_v4_compat?: boolean) => {
+    domain_separator_hash: string;
+    message_hash?: string;
+} & T;