@ledgerhq/hw-app-eth

  • Version 6.28.2
  • Published
  • 490 kB
  • 8 dependencies
  • Apache-2.0 license

Install

npm i @ledgerhq/hw-app-eth
yarn add @ledgerhq/hw-app-eth
pnpm add @ledgerhq/hw-app-eth

Overview

Ledger Hardware Wallet Ethereum Application API

Index

Classes

class Eth

class Eth {}
  • Ethereum API

    Example 1

    import Eth from "@ledgerhq/hw-app-eth"; const eth = new Eth(transport)

constructor

constructor(transport: Transport, scrambleKey?: string, loadConfig?: LoadConfig);

    property loadConfig

    loadConfig: LoadConfig;

      property transport

      transport: Transport;

        method eth2GetPublicKey

        eth2GetPublicKey: (
        path: string,
        boolDisplay?: boolean
        ) => Promise<{ publicKey: string }>;
        • get an Ethereum 2 BLS-12 381 public key for a given BIP 32 path.

          Parameter path

          a path in BIP 32 format boolDisplay optionally enable or not the display an object with a publicKey

          Example 1

          eth.eth2GetPublicKey("12381/3600/0/0").then(o => o.publicKey)

        method eth2SetWithdrawalIndex

        eth2SetWithdrawalIndex: (withdrawalIndex: number) => Promise<boolean>;
        • Set the index of a Withdrawal key used as withdrawal credentials in an ETH 2 deposit contract call signature

          It shall be run before the ETH 2 deposit transaction is signed. If not called, the index is set to 0

          Parameter withdrawalIndex

          index path in the EIP 2334 path m/12381/3600/withdrawalIndex/0 True if the method was executed successfully

        method getAddress

        getAddress: (
        path: string,
        boolDisplay?: boolean,
        boolChaincode?: boolean
        ) => Promise<{ publicKey: string; address: string; chainCode?: string }>;
        • get Ethereum address for a given BIP 32 path.

          Parameter path

          a path in BIP 32 format boolDisplay optionally enable or not the display boolChaincode optionally enable or not the chaincode request an object with a publicKey, address and (optionally) chainCode

          Example 1

          eth.getAddress("44'/60'/0'/0/0").then(o => o.address)

        method getAppConfiguration

        getAppConfiguration: () => Promise<{
        arbitraryDataEnabled: number;
        erc20ProvisioningNecessary: number;
        starkEnabled: number;
        starkv2Supported: number;
        version: string;
        }>;

        method getEIP1024PublicEncryptionKey

        getEIP1024PublicEncryptionKey: (
        path: string,
        boolDisplay?: boolean
        ) => Promise<{ publicKey: string }>;
        • get a public encryption key on Curve25519 according to EIP 1024

          Parameter path

          a path in BIP 32 format boolDisplay optionally enable or not the display an object with a publicKey

          Example 1

          eth.getEIP1024PublicEncryptionKey("44'/60'/0'/0/0").then(o => o.publicKey)

        method getEIP1024SharedSecret

        getEIP1024SharedSecret: (
        path: string,
        remotePublicKeyHex: string,
        boolDisplay?: boolean
        ) => Promise<{ sharedSecret: string }>;
        • get a shared secret on Curve25519 according to EIP 1024

          Parameter path

          a path in BIP 32 format

          Parameter remotePublicKeyHex

          remote Curve25519 public key boolDisplay optionally enable or not the display an object with a shared secret

          Example 1

          eth.getEIP1024SharedSecret("44'/60'/0'/0/0", "87020e80af6e07a6e4697f091eacadb9e7e6629cb7e5a8a371689a3ed53b3d64").then(o => o.sharedSecret)

        method provideERC20TokenInformation

        provideERC20TokenInformation: ({ data }: { data: Buffer }) => Promise<boolean>;

          method setExternalPlugin

          setExternalPlugin: (
          pluginName: string,
          contractAddress: string,
          selector: string
          ) => Promise<boolean>;

            method setLoadConfig

            setLoadConfig: (loadConfig: LoadConfig) => void;

              method setPlugin

              setPlugin: (data: string) => Promise<boolean>;

                method signEIP712HashedMessage

                signEIP712HashedMessage: (
                path: string,
                domainSeparatorHex: string,
                hashStructMessageHex: string
                ) => Promise<{ v: number; s: string; r: string }>;
                • Sign a prepared message following web3.eth.signTypedData specification. The host computes the domain separator and hashStruct(message)

                  Example 1

                  eth.signEIP712HashedMessage("44'/60'/0'/0/0", Buffer.from("0101010101010101010101010101010101010101010101010101010101010101").toString("hex"), Buffer.from("0202020202020202020202020202020202020202020202020202020202020202").toString("hex")).then(result => { var v = result['v'] - 27; v = v.toString(16); if (v.length < 2) { v = "0" + v; } console.log("Signature 0x" + result['r'] + result['s'] + v); })

                method signPersonalMessage

                signPersonalMessage: (
                path: string,
                messageHex: string
                ) => Promise<{ v: number; s: string; r: string }>;
                • You can sign a message according to eth_sign RPC call and retrieve v, r, s given the message and the BIP 32 path of the account to sign.

                  Example 1

                  eth.signPersonalMessage("44'/60'/0'/0/0", Buffer.from("test").toString("hex")).then(result => { var v = result['v'] - 27; v = v.toString(16); if (v.length < 2) { v = "0" + v; } console.log("Signature 0x" + result['r'] + result['s'] + v); })

                method signTransaction

                signTransaction: (
                path: string,
                rawTxHex: string,
                resolution?: LedgerEthTransactionResolution | null
                ) => Promise<{ s: string; v: string; r: string }>;
                • You can sign a transaction and retrieve v, r, s given the raw transaction and the BIP 32 path of the account to sign.

                  Parameter path

                  : the BIP32 path to sign the transaction on

                  Parameter rawTxHex

                  : the raw ethereum transaction in hexadecimal to sign

                  Parameter resolution

                  : resolution is an object with all "resolved" metadata necessary to allow the device to clear sign information. This includes: ERC20 token information, plugins, contracts, NFT signatures,... You must explicitly provide something to avoid having a warning. By default, you can use Ledger's service or your own resolution service. See services/types.js for the contract. Setting the value to "null" will fallback everything to blind signing but will still allow the device to sign the transaction.

                  Example 1

                  import ledgerService from "@ledgerhq/hw-app-eth/lib/services/ledger" const tx = "e8018504e3b292008252089428ee52a8f3d6e5d15f8b131996950d7f296c7952872bd72a2487400080"; // raw tx to sign const resolution = await ledgerService.resolveTransaction(tx); const result = eth.signTransaction("44'/60'/0'/0/0", tx, resolution); console.log(result);

                method starkGetPublicKey

                starkGetPublicKey: (path: string, boolDisplay?: boolean) => Promise<Buffer>;
                • get Stark public key for a given BIP 32 path.

                  Parameter path

                  a path in BIP 32 format boolDisplay optionally enable or not the display the Stark public key

                method starkProvideQuantum

                starkProvideQuantum: (
                operationContract: string | undefined,
                operationQuantization: BigNumber
                ) => Promise<boolean>;
                • provide quantization information before singing a deposit or withdrawal Stark powered contract call

                  It shall be run following a provideERC20TokenInformation call for the given contract

                  Parameter operationContract

                  contract address of the token to be transferred (not present for ETH)

                  Parameter operationQuantization

                  quantization used for the token to be transferred

                method starkProvideQuantum_v2

                starkProvideQuantum_v2: (
                operationContract: string | undefined,
                operationQuantizationType: StarkQuantizationType,
                operationQuantization?: BigNumber,
                operationMintableBlobOrTokenId?: BigNumber
                ) => Promise<boolean>;
                • provide quantization information before singing a deposit or withdrawal Stark powered contract call using the Starkex V2 protocol

                  It shall be run following a provideERC20TokenInformation call for the given contract

                  Parameter operationContract

                  contract address of the token to be transferred (not present for ETH)

                  Parameter operationQuantizationType

                  quantization type of the token to be transferred operationQuantization quantization used for the token to be transferred (not present for erc 721 or mintable erc 721) operationMintableBlobOrTokenId mintable blob (mintable erc 20 / mintable erc 721) or token id (erc 721) of the token to be transferred

                method starkSignOrder

                starkSignOrder: (
                path: string,
                sourceTokenAddress: string | undefined,
                sourceQuantization: BigNumber,
                destinationTokenAddress: string | undefined,
                destinationQuantization: BigNumber,
                sourceVault: number,
                destinationVault: number,
                amountSell: BigNumber,
                amountBuy: BigNumber,
                nonce: number,
                timestamp: number
                ) => Promise<Buffer | { r: string; s: string }>;
                • sign a Stark order

                  Parameter path

                  a path in BIP 32 format sourceTokenAddress contract address of the source token (not present for ETH)

                  Parameter sourceQuantization

                  quantization used for the source token destinationTokenAddress contract address of the destination token (not present for ETH)

                  Parameter destinationQuantization

                  quantization used for the destination token

                  Parameter sourceVault

                  ID of the source vault

                  Parameter destinationVault

                  ID of the destination vault

                  Parameter amountSell

                  amount to sell

                  Parameter amountBuy

                  amount to buy

                  Parameter nonce

                  transaction nonce

                  Parameter timestamp

                  transaction validity timestamp the signature

                method starkSignOrder_v2

                starkSignOrder_v2: (
                path: string,
                sourceTokenAddress: string | undefined,
                sourceQuantizationType: StarkQuantizationType,
                sourceQuantization: BigNumber | undefined,
                sourceMintableBlobOrTokenId: BigNumber | undefined,
                destinationTokenAddress: string | undefined,
                destinationQuantizationType: StarkQuantizationType,
                destinationQuantization: BigNumber | undefined,
                destinationMintableBlobOrTokenId: BigNumber | undefined,
                sourceVault: number,
                destinationVault: number,
                amountSell: BigNumber,
                amountBuy: BigNumber,
                nonce: number,
                timestamp: number
                ) => Promise<Buffer | { r: string; s: string }>;
                • sign a Stark order using the Starkex V2 protocol

                  Parameter path

                  a path in BIP 32 format sourceTokenAddress contract address of the source token (not present for ETH)

                  Parameter sourceQuantizationType

                  quantization type used for the source token sourceQuantization quantization used for the source token (not present for erc 721 or mintable erc 721) sourceMintableBlobOrTokenId mintable blob (mintable erc 20 / mintable erc 721) or token id (erc 721) associated to the source token destinationTokenAddress contract address of the destination token (not present for ETH)

                  Parameter destinationQuantizationType

                  quantization type used for the destination token destinationQuantization quantization used for the destination token (not present for erc 721 or mintable erc 721) destinationMintableBlobOrTokenId mintable blob (mintable erc 20 / mintable erc 721) or token id (erc 721) associated to the destination token

                  Parameter sourceVault

                  ID of the source vault

                  Parameter destinationVault

                  ID of the destination vault

                  Parameter amountSell

                  amount to sell

                  Parameter amountBuy

                  amount to buy

                  Parameter nonce

                  transaction nonce

                  Parameter timestamp

                  transaction validity timestamp the signature

                method starkSignTransfer

                starkSignTransfer: (
                path: string,
                transferTokenAddress: string | undefined,
                transferQuantization: BigNumber,
                targetPublicKey: string,
                sourceVault: number,
                destinationVault: number,
                amountTransfer: BigNumber,
                nonce: number,
                timestamp: number
                ) => Promise<Buffer | { r: string; s: string }>;
                • sign a Stark transfer

                  Parameter path

                  a path in BIP 32 format transferTokenAddress contract address of the token to be transferred (not present for ETH)

                  Parameter transferQuantization

                  quantization used for the token to be transferred

                  Parameter targetPublicKey

                  target Stark public key

                  Parameter sourceVault

                  ID of the source vault

                  Parameter destinationVault

                  ID of the destination vault

                  Parameter amountTransfer

                  amount to transfer

                  Parameter nonce

                  transaction nonce

                  Parameter timestamp

                  transaction validity timestamp the signature

                method starkSignTransfer_v2

                starkSignTransfer_v2: (
                path: string,
                transferTokenAddress: string | undefined,
                transferQuantizationType: StarkQuantizationType,
                transferQuantization: BigNumber | undefined,
                transferMintableBlobOrTokenId: BigNumber | undefined,
                targetPublicKey: string,
                sourceVault: number,
                destinationVault: number,
                amountTransfer: BigNumber,
                nonce: number,
                timestamp: number,
                conditionalTransferAddress?: string,
                conditionalTransferFact?: BigNumber
                ) => Promise<Buffer | { r: string; s: string }>;
                • sign a Stark transfer or conditional transfer using the Starkex V2 protocol

                  Parameter path

                  a path in BIP 32 format transferTokenAddress contract address of the token to be transferred (not present for ETH)

                  Parameter transferQuantizationType

                  quantization type used for the token to be transferred transferQuantization quantization used for the token to be transferred (not present for erc 721 or mintable erc 721) transferMintableBlobOrTokenId mintable blob (mintable erc 20 / mintable erc 721) or token id (erc 721) associated to the token to be transferred

                  Parameter targetPublicKey

                  target Stark public key

                  Parameter sourceVault

                  ID of the source vault

                  Parameter destinationVault

                  ID of the destination vault

                  Parameter amountTransfer

                  amount to transfer

                  Parameter nonce

                  transaction nonce

                  Parameter timestamp

                  transaction validity timestamp conditionalTransferAddress onchain address of the condition for a conditional transfer conditionalTransferFact fact associated to the condition for a conditional transfer the signature

                method starkUnsafeSign

                starkUnsafeSign: (
                path: string,
                hash: string
                ) => Promise<Buffer | { r: string; s: string }>;
                • sign the given hash over the Stark curve It is intended for speed of execution in case an unknown Stark model is pushed and should be avoided as much as possible.

                  Parameter path

                  a path in BIP 32 format

                  Parameter hash

                  hexadecimal hash to sign the signature

                Type Aliases

                type StarkQuantizationType

                type StarkQuantizationType =
                | 'eth'
                | 'erc20'
                | 'erc721'
                | 'erc20mintable'
                | 'erc721mintable';

                  Package Files (1)

                  Dependencies (8)

                  Dev Dependencies (0)

                  No dev dependencies.

                  Peer Dependencies (0)

                  No peer dependencies.

                  Badge

                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@ledgerhq/hw-app-eth.

                  • Markdown
                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@ledgerhq/hw-app-eth)
                  • HTML
                    <a href="https://www.jsdocs.io/package/@ledgerhq/hw-app-eth"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>