@ledgerhq/hw-transport

property deviceModel

deviceModel: any;

property ErrorMessage_ListenTimeout

static ErrorMessage_ListenTimeout: string;

property ErrorMessage_NoDeviceFound

static ErrorMessage_NoDeviceFound: string;

property exchangeAtomicImpl

exchangeAtomicImpl: (f: () => Promise<Buffer | void>) => Promise<Buffer | void>;

property exchangeBusyPromise

exchangeBusyPromise: Promise<void>;

property exchangeTimeout

exchangeTimeout: number;

property isSupported

static readonly isSupported: () => Promise<boolean>;

• Check if the transport is supported on the current platform/browser.

  Returns

  {Promise} A promise that resolves with a boolean indicating support.

property list

static readonly list: () => Promise<Array<any>>;

• List all available descriptors for the transport. For a better granularity, checkout listen().

  Returns

  {Promise<Array>} A promise that resolves with an array of descriptors.

  Example 1

  TransportFoo.list().then(descriptors => ...)

property listen

static readonly listen: (
    observer: Observer<DescriptorEvent<any>>
) => Subscription;

• Listen for device events for the transport. The method takes an observer of DescriptorEvent and returns a Subscription. A DescriptorEvent is an object containing a "descriptor" and a "type" field. The "type" field can be "add" or "remove", and the "descriptor" field can be passed to the "open" method. The "listen" method will first emit all currently connected devices and then will emit events as they occur, such as when a USB device is plugged in or a Bluetooth device becomes discoverable.

  Parameter observer

  An object with "next", "error", and "complete" functions, following the observer pattern.

  Returns

  {Subscription} A Subscription object on which you can call ".unsubscribe()" to stop listening to descriptors.

  Example 1

  const sub = TransportFoo.listen({ next: e => { if (e.type==="add") { sub.unsubscribe(); const transport = await TransportFoo.open(e.descriptor); ... } }, error: error => {}, complete: () => {} })

property open

static readonly open: (descriptor?: any, timeout?: number) => Promise<Transport>;

• Attempt to create a Transport instance with a specific descriptor.

  Parameter descriptor

  The descriptor to open the transport with.

  Parameter timeout

  An optional timeout for the transport connection.

  Returns

  {Promise} A promise that resolves with a Transport instance.

  Example 1

  TransportFoo.open(descriptor).then(transport => ...)

property send

send: (
    cla: number,
    ins: number,
    p1: number,
    p2: number,
    data?: Buffer,
    statusList?: Array<number>
) => Promise<Buffer>;

• Send data to the device using the higher level API.

  Parameter cla

  The instruction class for the command.

  Parameter ins

  The instruction code for the command.

  Parameter p1

  The first parameter for the instruction.

  Parameter p2

  The second parameter for the instruction.

  Parameter data

  The data to be sent. Defaults to an empty buffer.

  Parameter statusList

  A list of acceptable status codes for the response. Defaults to [StatusCodes.OK].

  Returns

  {Promise} A promise that resolves with the response data from the device.

property unresponsiveTimeout

unresponsiveTimeout: number;

method close

close: () => Promise<void>;

• Close the connection with the device.

  Returns

  {Promise} A promise that resolves when the transport is closed.

method create

static create: (
    openTimeout?: number,
    listenTimeout?: number
) => Promise<Transport>;

• create() allows to open the first descriptor available or throw if there is none or if timeout is reached. This is a light helper, alternative to using listen() and open() (that you may need for any more advanced usecase)

  Example 1

  TransportFoo.create().then(transport => ...)

method decorateAppAPIMethod

decorateAppAPIMethod: <R, A extends any[]>(
    methodName: string,
    f: (...args: A) => Promise<R>,
    ctx: any,
    scrambleKey: string
) => (...args: A) => Promise<R>;

method decorateAppAPIMethods

decorateAppAPIMethods: (
    self: Record<string, any>,
    methods: Array<string>,
    scrambleKey: string
) => void;

method emit

emit: (event: string, ...args: any) => void;

method exchange

exchange: (_apdu: Buffer) => Promise<Buffer>;

• Send data to the device using a low level API. It's recommended to use the "send" method for a higher level API.

  Parameter apdu

  The data to send.

  Returns

  {Promise} A promise that resolves with the response data from the device.

method exchangeBulk

exchangeBulk: (apdus: Buffer[], observer: Observer<Buffer>) => Subscription;

• Send apdus in batch to the device using a low level API. The default implementation is to call exchange for each apdu.

  Parameter apdus

  array of apdus to send.

  Parameter observer

  an observer that will receive the response of each apdu.

  Returns

  {Subscription} A Subscription object on which you can call ".unsubscribe()" to stop sending apdus.

method off

off: (eventName: string, cb: (...args: Array<any>) => any) => void;

• Stop listening to an event on an instance of transport.

method on

on: (eventName: string, cb: (...args: Array<any>) => any) => void;

• Listen for an event on the transport instance. Transport implementations may have specific events. Common events include: "disconnect" : triggered when the transport is disconnected.

  Parameter eventName

  The name of the event to listen for.

  Parameter cb

  The callback function to be invoked when the event occurs.

method setDebugMode

setDebugMode: () => void;

• Enable or not logs of the binary exchange

method setExchangeTimeout

setExchangeTimeout: (exchangeTimeout: number) => void;

• Set a timeout (in milliseconds) for the exchange call. Only some transport might implement it. (e.g. U2F)

method setExchangeUnresponsiveTimeout

setExchangeUnresponsiveTimeout: (unresponsiveTimeout: number) => void;

• Define the delay before emitting "unresponsive" on an exchange that does not respond

method setScrambleKey

setScrambleKey: (_key: string) => void;

• Set the "scramble key" for the next data exchanges with the device. Each app can have a different scramble key and it is set internally during instantiation.

  Parameter key

  The scramble key to set.

  Deprecated

  This method is no longer needed for modern transports and should be migrated away from.

property descriptor

descriptor: Descriptor;

property device

device?: Device;

property deviceModel

deviceModel?: DeviceModel | null | undefined;

property type

type: DescriptorEventType;