@ledgerhq/coin-casper 1.4.0-next.0

package/src/bridge/buildOptimisticOperation.ts

@@ -0,0 +1,31 @@
+import { OperationType } from "@ledgerhq/types-live";
+import { getAddress } from "./bridgeHelpers/addresses";
+import { CasperAccount, CasperOperation, Transaction } from "../types";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+
+export const buildOptimisticOperation = (
+  account: CasperAccount,
+  transaction: Transaction,
+  hash: string,
+  operationType: OperationType = "OUT",
+): CasperOperation => {
+  const { id: accountId } = account;
+  const { address } = getAddress(account);
+
+  return {
+    id: encodeOperationId(accountId, hash, operationType),
+    hash,
+    type: operationType,
+    senders: [address],
+    recipients: [transaction.recipient],
+    accountId,
+    value: transaction.amount.plus(transaction.fees),
+    fee: transaction.fees,
+    blockHash: null,
+    blockHeight: null,
+    date: new Date(),
+    extra: {
+      transferId: transaction.transferId,
+    },
+  };
+};

package/src/bridge/createTransaction.ts

@@ -0,0 +1,15 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  // log("debug", "[createTransaction] creating base tx");
+
+  return {
+    family: "casper",
+    amount: new BigNumber(0),
+    fees: new BigNumber(0),
+    recipient: "",
+    useAllAmount: false,
+  };
+};

package/src/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,46 @@
+import { log } from "@ledgerhq/logs";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import { Transaction, TransactionStatus } from "../types";
+import { methodToString } from "../common-logic";
+import BigNumber from "bignumber.js";
+
+export type ExtraDeviceTransactionField = {
+  type: "casper.extendedAmount";
+  label: string;
+  value: number | BigNumber;
+};
+
+type DeviceTransactionField = CommonDeviceTransactionField | ExtraDeviceTransactionField;
+
+function getDeviceTransactionConfig({
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+  fields.push({
+    type: "text",
+    label: "Type",
+    value: methodToString(0),
+  });
+  fields.push({
+    type: "casper.extendedAmount",
+    label: "Fee",
+    value: transaction.fees,
+  });
+  fields.push({
+    type: "casper.extendedAmount",
+    label: "Amount",
+    value: transaction.amount,
+  });
+
+  log("debug", `Transaction config ${JSON.stringify(fields)}`);
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,26 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { Transaction } from "../types";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  let balance = mainAccount.spendableBalance;
+
+  if (balance.eq(0)) return balance;
+
+  const estimatedFees = transaction?.fees ?? getEstimatedFees();
+
+  if (balance.lte(estimatedFees)) return new BigNumber(0);
+
+  balance = balance.minus(estimatedFees);
+
+  // log("debug", "[estimateMaxSpendable] finish fn");
+
+  return balance;
+};

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,96 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { getAddress, isAddressValid } from "./bridgeHelpers/addresses";
+import { CasperAccount, Transaction, TransactionStatus } from "../types";
+import { isTransferIdValid } from "./bridgeHelpers/transferId";
+import { CasperInvalidTransferId } from "../errors";
+import {
+  CASPER_MINIMUM_VALID_AMOUNT_MOTES,
+  CASPER_MAX_TRANSFER_ID,
+  MayBlockAccountError,
+  InvalidMinimumAmountError,
+} from "../consts";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  CasperAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+
+  const { balance, spendableBalance } = account;
+  const { address } = getAddress(account);
+  const { recipient, useAllAmount } = transaction;
+  let { amount } = transaction;
+
+  if (!recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!isAddressValid(recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  } else if (recipient.toLowerCase() === address.toLowerCase()) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (!isAddressValid(address)) {
+    errors.sender = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  } else if (!isTransferIdValid(transaction.transferId)) {
+    errors.sender = new CasperInvalidTransferId("", {
+      maxTransferId: CASPER_MAX_TRANSFER_ID,
+    });
+  }
+
+  const estimatedFees = transaction.fees;
+
+  let totalSpent = new BigNumber(0);
+
+  if (useAllAmount) {
+    totalSpent = account.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (!useAllAmount) {
+    totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    }
+
+    if (totalSpent.gt(account.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (amount.lt(CASPER_MINIMUM_VALID_AMOUNT_MOTES) && !errors.amount) {
+    errors.amount = InvalidMinimumAmountError;
+  }
+
+  if (
+    spendableBalance.minus(totalSpent).minus(estimatedFees).lt(CASPER_MINIMUM_VALID_AMOUNT_MOTES)
+  ) {
+    warnings.amount = MayBlockAccountError;
+  }
+
+  // log("debug", "[getTransactionStatus] finish fn");
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};

package/src/bridge/index.ts

@@ -0,0 +1,65 @@
+import {
+  getSerializedAddressParameters,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+  updateTransaction,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import resolver from "../signer";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus, CasperSigner } from "../types";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import { getAccountShape } from "./bridgeHelpers/accountShape";
+import { buildSignOperation } from "./signOperation";
+import { broadcast } from "./broadcast";
+
+function buildCurrencyBridge(signerContext: SignerContext<CasperSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+const sync = makeSync({ getAccountShape });
+
+function buildAccountBridge(
+  signerContext: SignerContext<CasperSigner>,
+): AccountBridge<Transaction, Account, TransactionStatus> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    getSerializedAddressParameters,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<CasperSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,19 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { updateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { Transaction } from "../types";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+): Promise<Transaction> => {
+  // log("debug", "[prepareTransaction] start fn");
+  const fees = getEstimatedFees();
+
+  const amount = transaction.useAllAmount
+    ? account.spendableBalance.minus(transaction.fees)
+    : transaction.amount;
+
+  // log("debug", "[prepareTransaction] finish fn");
+  return updateTransaction(transaction, { fees, amount });
+};

package/src/bridge/signOperation.ts

@@ -0,0 +1,73 @@
+import { Observable } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import { DeployUtil } from "casper-js-sdk";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { casperGetCLPublicKey, getAddress } from "../bridge/bridgeHelpers/addresses";
+import { createNewDeploy } from "../bridge/bridgeHelpers/txn";
+import { Transaction } from "../types";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { CasperSigner } from "../types";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<CasperSigner>,
+  ): AccountBridge<Transaction, Account>["signOperation"] =>
+  ({ account, transaction, deviceId }) =>
+    new Observable(o => {
+      async function main() {
+        // log("debug", "[signOperation] start fn");
+
+        const { recipient } = transaction;
+        const { address, derivationPath } = getAddress(account);
+        const deploy = createNewDeploy(
+          address,
+          recipient,
+          transaction.amount,
+          transaction.fees,
+          transaction.transferId,
+        );
+
+        // Serialize tx
+        const deployBytes = DeployUtil.deployToBytes(deploy);
+        log("debug", `[signOperation] serialized deploy: [${deployBytes.toString()}]`);
+        o.next({
+          type: "device-signature-requested",
+        });
+
+        // Sign by device
+        const { r } = await signerContext(deviceId, async signer => {
+          const r = await signer.sign(derivationPath, Buffer.from(deployBytes));
+          return { r };
+        });
+
+        o.next({
+          type: "device-signature-granted",
+        });
+
+        // signature verification
+        const deployHash = deploy.hash.toString();
+        const signature = r.signatureRS;
+
+        // sign deploy object
+        const signedDeploy = DeployUtil.setSignature(
+          deploy,
+          signature,
+          casperGetCLPublicKey(address),
+        );
+
+        const operation = buildOptimisticOperation(account, transaction, deployHash);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: JSON.stringify(DeployUtil.deployToJson(signedDeploy)),
+          },
+        });
+      }
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/transaction.ts

@@ -0,0 +1,61 @@
+import type { Transaction, TransactionRaw } from "../types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import BigNumber from "bignumber.js";
+
+export const formatTransaction = (
+  { recipient, useAllAmount, amount }: Transaction,
+  account: Account,
+): string => `
+SEND ${
+  useAllAmount
+    ? "MAX"
+    : amount.isZero()
+      ? ""
+      : " " +
+        formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+}
+TO ${recipient}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    fees: new BigNumber(tr.fees),
+    amount: new BigNumber(tr.amount),
+    transferId: tr.transferId,
+  };
+};
+
+const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+
+  return {
+    ...common,
+    family: t.family,
+    amount: t.amount.toFixed(),
+    fees: t.fees.toString(),
+    transferId: t.transferId,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/common-logic/index.ts

@@ -0,0 +1,10 @@
+export {
+  isNoErrorReturnCode,
+  getPath,
+  isValidHex,
+  isValidBase64,
+  isError,
+  methodToString,
+  getBufferFromString,
+  getRandomTransferID,
+} from "./utils";

package/src/common-logic/utils.ts

@@ -0,0 +1,53 @@
+import BigNumber from "bignumber.js";
+
+const validHexRegExp = new RegExp(/[0-9A-Fa-f]{6}/g);
+const validBase64RegExp = new RegExp(
+  /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{3}=|[A-Za-z\d+/]{2}==)?$/,
+);
+
+export const isNoErrorReturnCode = (code: number): boolean => code === 0x9000;
+
+export const getPath = (path: string): string =>
+  path && path.substring(0, 2) !== "m/" ? `m/${path}` : path;
+
+export const isValidHex = (msg: string): boolean => validHexRegExp.test(msg);
+export const isValidBase64 = (msg: string): boolean => validBase64RegExp.test(msg);
+
+export const isError = (r: { returnCode: number; errorMessage: string }): void => {
+  if (!isNoErrorReturnCode(r.returnCode)) throw new Error(`${r.returnCode} - ${r.errorMessage}`);
+};
+
+export const methodToString = (method: number): string => {
+  switch (method) {
+    case 0:
+      return "Token transfer";
+    default:
+      return "Unknown";
+  }
+};
+
+export const getBufferFromString = (message: string): Buffer => {
+  if (isValidHex(message)) {
+    return Buffer.from(message, "hex");
+  }
+
+  if (isValidBase64(message)) {
+    return Buffer.from(message, "base64");
+  }
+
+  return Buffer.from(message);
+};
+
+function randomIntFromInterval(min: number, max: number): string {
+  const minBig = new BigNumber(min);
+  const maxBig = new BigNumber(max);
+
+  const random = BigNumber.random().multipliedBy(maxBig.minus(minBig).plus(1)).plus(minBig);
+  const randomInt = random.integerValue(BigNumber.ROUND_FLOOR);
+
+  return randomInt.toString();
+}
+
+export function getRandomTransferID(): string {
+  return randomIntFromInterval(0, Number.MAX_SAFE_INTEGER);
+}

package/src/common-logic/utils.unit.test.ts

@@ -0,0 +1,75 @@
+import { CLPublicKeyTag } from "casper-js-sdk";
+import { casperAddressFromPubKey, isAddressValid } from "../bridge/bridgeHelpers/addresses";
+
+describe("Casper addresses", () => {
+  const pubKeys = {
+    // valid
+    validSecp256k1: "0203a17118ec0e64c4e4fdbdbee0ea14d118c9aaf08c6c81bbb776cae607ceb84ecb",
+    validEd25519: "016470ae57b0a3ad5a679d2e0422909bfb9ded445e20cbe6b4c9806f844c94d401",
+    validSecp256k1Checksum: "0203A17118eC0e64c4e4FdbDbEe0eA14D118C9aAf08C6c81bbB776Cae607cEB84EcB", // Checksummed
+    validEd25519Checksum: "016470AE57b0a3aD5A679d2e0422909Bfb9dEd445e20cbE6B4c9806f844c94d401", // Checksummed
+    // invalid
+    invalidSecp256k1: "0203A17118ec0e64c4e4fdbdbee0ea14d118c9aaf08c6c81bbc776cae607ceb84ecb",
+    invalidEd25519: "016470ae57b0a3ad5a679d2e0422909bfb9ded445e20cbe6b8c9806f844c94D401",
+    invalidAddresstype: "036470ae57b0a3ad5a679d2e0422909bfb9ded445e20cbe6b8c9806f844c94d401", // Invalid address type
+    invalidLength: "12345", // Invalid length
+    invalidCharacter: "xyz123", // Contains non-hex characters
+    invalidChecksum: "016470ae57b0a3ad5a679d2e0422909bfb9ded445e20cbe6b4c9806f844c94D400", // Invalid checksum
+  };
+
+  test("Check if valid addresses are valid", () => {
+    expect(isAddressValid(pubKeys.validEd25519)).toBe(true);
+    expect(isAddressValid(pubKeys.validSecp256k1)).toBe(true);
+  });
+
+  test("Check if invalid addresses are invalid", () => {
+    expect(isAddressValid(pubKeys.invalidEd25519)).toBe(false);
+    expect(isAddressValid(pubKeys.invalidSecp256k1)).toBe(false);
+    expect(isAddressValid(pubKeys.invalidLength)).toBe(false);
+    expect(isAddressValid(pubKeys.invalidCharacter)).toBe(false);
+    expect(isAddressValid(pubKeys.invalidChecksum)).toBe(false);
+  });
+
+  test("Get the address from the publick key", () => {
+    /**
+     * Extracts the public key and key signature from a given Casper address.
+     *
+     * @param {string} address - The Casper address from which to extract the public key and key signature.
+     * @returns {{ pubkey: Buffer, keySig: CLPublicKeyTag }} An object containing the public key as a Buffer and the key signature as a CLPublicKeyTag.
+     */
+    function casperPubKeyFromAddress(address: string): {
+      pubkey: Buffer;
+      keySig: CLPublicKeyTag;
+    } {
+      const keySig = parseInt(address.slice(0, 2), 10) as CLPublicKeyTag;
+      const pubkeyHex = address.slice(2);
+      const pubkey = Buffer.from(pubkeyHex, "hex");
+      return { pubkey, keySig };
+    }
+
+    expect(
+      casperAddressFromPubKey(
+        casperPubKeyFromAddress(pubKeys.validSecp256k1).pubkey,
+        CLPublicKeyTag.SECP256K1,
+      ),
+    ).toBe(pubKeys.validSecp256k1);
+    expect(
+      casperAddressFromPubKey(
+        casperPubKeyFromAddress(pubKeys.validSecp256k1Checksum).pubkey,
+        CLPublicKeyTag.SECP256K1,
+      ),
+    ).toBe(pubKeys.validSecp256k1Checksum.toLowerCase());
+    expect(
+      casperAddressFromPubKey(
+        casperPubKeyFromAddress(pubKeys.validEd25519).pubkey,
+        CLPublicKeyTag.ED25519,
+      ),
+    ).toBe(pubKeys.validEd25519);
+    expect(
+      casperAddressFromPubKey(
+        casperPubKeyFromAddress(pubKeys.validEd25519Checksum).pubkey,
+        CLPublicKeyTag.ED25519,
+      ),
+    ).toBe(pubKeys.validEd25519Checksum.toLowerCase());
+  });
+});

package/src/consts.ts

@@ -0,0 +1,18 @@
+import { InvalidMinimumAmount, MayBlockAccount } from "./errors";
+
+export const CASPER_FEES_MOTES = 0.1 * 1e9;
+export const CASPER_FEES_CSPR = 0.1;
+export const CASPER_MINIMUM_VALID_AMOUNT_MOTES = 2.5 * 1e9;
+export const CASPER_MINIMUM_VALID_AMOUNT_CSPR = 2.5;
+export const CASPER_NETWORK = "casper";
+export const CASPER_CHECKSUM_HEX_LEN = 32;
+
+export const CASPER_MAX_TRANSFER_ID = "18446744073709551615";
+
+export const MayBlockAccountError = new MayBlockAccount("", {
+  minAmount: `${CASPER_MINIMUM_VALID_AMOUNT_CSPR + CASPER_FEES_CSPR} CSPR`,
+});
+
+export const InvalidMinimumAmountError = new InvalidMinimumAmount("", {
+  minAmount: `${CASPER_MINIMUM_VALID_AMOUNT_CSPR} CSPR`,
+});

package/src/errors.ts

@@ -0,0 +1,5 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const CasperInvalidTransferId = createCustomErrorClass("CasperInvalidTransferId");
+export const InvalidMinimumAmount = createCustomErrorClass("InvalidMinimumAmount");
+export const MayBlockAccount = createCustomErrorClass("MayBlockAccount");

package/src/hw-signMessage.ts

@@ -0,0 +1,30 @@
+import { log } from "@ledgerhq/logs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { CasperSigner } from "./types";
+import { getBufferFromString } from "./common-logic/utils";
+import { Account, AnyMessage } from "@ledgerhq/types-live";
+
+export const signMessage =
+  (signerContext: SignerContext<CasperSigner>) =>
+  async (deviceId: string, account: Account, { message }: AnyMessage) => {
+    log("debug", "start signMessage process");
+
+    if (!message) throw new Error(`Message cannot be empty`);
+    if (typeof message !== "string") throw new Error(`Signing EIP712Message not supported`);
+
+    const r = await signerContext(
+      deviceId,
+      async signer => await signer.sign(account.freshAddressPath, getBufferFromString(message)),
+    );
+
+    return {
+      rsv: {
+        r: Buffer.from(r.signature_compact.slice(0, 32)).toString("hex"),
+        s: Buffer.from(r.signature_compact.slice(32, 64)).toString("hex"),
+        v: parseInt(Buffer.from(r.signature_compact.slice(64, 65)).toString("hex"), 16),
+      },
+      signature: `0x${Buffer.from(r.signature_compact).toString("hex")}`,
+    };
+  };
+
+export default { signMessage };

package/src/signer/getAddress.ts

@@ -0,0 +1,31 @@
+import { log } from "@ledgerhq/logs";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { CLPublicKeyTag } from "casper-js-sdk";
+import { casperAddressFromPubKey } from "../bridge/bridgeHelpers/addresses";
+import { CasperSigner } from "../types";
+
+function resolver(signerContext: SignerContext<CasperSigner>): GetAddressFn {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    log("debug", "start getAddress process");
+
+    const { r } = await signerContext(deviceId, async signer => {
+      const r = verify
+        ? await signer.showAddressAndPubKey(path)
+        : await signer.getAddressAndPubKey(path);
+
+      return { r };
+    });
+
+    return {
+      path,
+      address: r.Address.length
+        ? r.Address.toString().toLowerCase()
+        : casperAddressFromPubKey(r.publicKey, CLPublicKeyTag.SECP256K1),
+      publicKey: r.publicKey.toString("hex"),
+    };
+  };
+}
+
+export default resolver;

package/src/signer/index.ts

@@ -0,0 +1,3 @@
+import resolver from "./getAddress";
+
+export default resolver;