@ledgerhq/hw-app-eth

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 signEIP712Message

signEIP712Message: (
    path: string,
    jsonMessage: EIP712Message,
    fullImplem?: boolean
) => Promise<{ v: number; s: string; r: string }>;

• Sign an EIP-721 formatted message following the specification here: https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.asc#sign-eth-eip-712 ⚠️ This method is not compatible with nano S (LNS). Make sure to use a try/catch to fallback on the signEIP712HashedMessage method ⚠️

  Parameter path

  derivationPath

  Parameter jsonMessage

  message to sign

  Parameter fullImplem

  use the legacy implementation

  Returns

  {Promise}

  Example 1

  eth.signEIP721Message("44'/60'/0'/0/0", { domain: { chainId: 69, name: "Da Domain", verifyingContract: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC", version: "1" }, types: { "EIP712Domain": [ { name: "name", type: "string" }, { name: "version", type: "string" }, { name: "chainId", type: "uint256" }, { name: "verifyingContract", type: "address" } ], "Test": [ { name: "contents", type: "string" } ] }, primaryType: "Test", message: {contents: "Hello, Bob!"}, })

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" 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