@ledgerhq/coin-vechain 2.2.0-next.0

package/src/contracts/abis/VIP180.ts

@@ -0,0 +1,265 @@
+import { abi } from "thor-devkit";
+
+/**
+ * EVENTS
+ */
+const ApprovalEvent: abi.Event.Definition = {
+  anonymous: false,
+  inputs: [
+    {
+      indexed: true,
+      internalType: "address",
+      name: "owner",
+      type: "address",
+    },
+    {
+      indexed: true,
+      internalType: "address",
+      name: "spender",
+      type: "address",
+    },
+    {
+      indexed: false,
+      internalType: "uint256",
+      name: "value",
+      type: "uint256",
+    },
+  ],
+  name: "Approval",
+  type: "event",
+};
+const TransferEvent: abi.Event.Definition = {
+  anonymous: false,
+  inputs: [
+    {
+      indexed: true,
+      internalType: "address",
+      name: "from",
+      type: "address",
+    },
+    {
+      indexed: true,
+      internalType: "address",
+      name: "to",
+      type: "address",
+    },
+    {
+      indexed: false,
+      internalType: "uint256",
+      name: "value",
+      type: "uint256",
+    },
+  ],
+  name: "Transfer",
+  type: "event",
+};
+
+/**
+ * FUNCTIONS
+ */
+const allowance: abi.Function.Definition = {
+  inputs: [
+    {
+      internalType: "address",
+      name: "owner",
+      type: "address",
+    },
+    {
+      internalType: "address",
+      name: "spender",
+      type: "address",
+    },
+  ],
+  name: "allowance",
+  outputs: [
+    {
+      internalType: "uint256",
+      name: "",
+      type: "uint256",
+    },
+  ],
+  stateMutability: "view",
+  type: "function",
+};
+const approve: abi.Function.Definition = {
+  inputs: [
+    {
+      internalType: "address",
+      name: "spender",
+      type: "address",
+    },
+    {
+      internalType: "uint256",
+      name: "amount",
+      type: "uint256",
+    },
+  ],
+  name: "approve",
+  outputs: [
+    {
+      internalType: "bool",
+      name: "",
+      type: "bool",
+    },
+  ],
+  stateMutability: "nonpayable",
+  type: "function",
+};
+const balanceOf: abi.Function.Definition = {
+  inputs: [
+    {
+      internalType: "address",
+      name: "account",
+      type: "address",
+    },
+  ],
+  name: "balanceOf",
+  outputs: [
+    {
+      internalType: "uint256",
+      name: "",
+      type: "uint256",
+    },
+  ],
+  stateMutability: "view",
+  type: "function",
+};
+const decimals: abi.Function.Definition = {
+  inputs: [],
+  name: "decimals",
+  outputs: [
+    {
+      internalType: "uint8",
+      name: "",
+      type: "uint8",
+    },
+  ],
+  stateMutability: "view",
+  type: "function",
+};
+const name: abi.Function.Definition = {
+  inputs: [],
+  name: "name",
+  outputs: [
+    {
+      internalType: "string",
+      name: "",
+      type: "string",
+    },
+  ],
+  stateMutability: "view",
+  type: "function",
+};
+const supportsInterface: abi.Function.Definition = {
+  inputs: [
+    {
+      internalType: "bytes4",
+      name: "interfaceId",
+      type: "bytes4",
+    },
+  ],
+  name: "supportsInterface",
+  outputs: [
+    {
+      internalType: "bool",
+      name: "",
+      type: "bool",
+    },
+  ],
+  stateMutability: "view",
+  type: "function",
+};
+const symbol: abi.Function.Definition = {
+  inputs: [],
+  name: "symbol",
+  outputs: [
+    {
+      internalType: "string",
+      name: "",
+      type: "string",
+    },
+  ],
+  stateMutability: "view",
+  type: "function",
+};
+const totalSupply: abi.Function.Definition = {
+  inputs: [],
+  name: "totalSupply",
+  outputs: [
+    {
+      internalType: "uint256",
+      name: "",
+      type: "uint256",
+    },
+  ],
+  stateMutability: "view",
+  type: "function",
+};
+const transfer: abi.Function.Definition = {
+  inputs: [
+    {
+      internalType: "address",
+      name: "to",
+      type: "address",
+    },
+    {
+      internalType: "uint256",
+      name: "amount",
+      type: "uint256",
+    },
+  ],
+  name: "transfer",
+  outputs: [
+    {
+      internalType: "bool",
+      name: "",
+      type: "bool",
+    },
+  ],
+  stateMutability: "nonpayable",
+  type: "function",
+};
+const transferFrom: abi.Function.Definition = {
+  inputs: [
+    {
+      internalType: "address",
+      name: "from",
+      type: "address",
+    },
+    {
+      internalType: "address",
+      name: "to",
+      type: "address",
+    },
+    {
+      internalType: "uint256",
+      name: "amount",
+      type: "uint256",
+    },
+  ],
+  name: "transferFrom",
+  outputs: [
+    {
+      internalType: "bool",
+      name: "",
+      type: "bool",
+    },
+  ],
+  stateMutability: "nonpayable",
+  type: "function",
+};
+
+export default {
+  ApprovalEvent: new abi.Event(ApprovalEvent),
+  TransferEvent: new abi.Event(TransferEvent),
+  allowance: new abi.Function(allowance),
+  approve: new abi.Function(approve),
+  balanceOf: new abi.Function(balanceOf),
+  decimals: new abi.Function(decimals),
+  name: new abi.Function(name),
+  supportsInterface: new abi.Function(supportsInterface),
+  symbol: new abi.Function(symbol),
+  totalSupply: new abi.Function(totalSupply),
+  transfer: new abi.Function(transfer),
+  transferFrom: new abi.Function(transferFrom),
+};

package/src/contracts/abis/params.ts

@@ -0,0 +1,70 @@
+import { abi } from "thor-devkit";
+
+/**
+ * FUNCTIONS
+ */
+const set: abi.Function.Definition = {
+  constant: false,
+  inputs: [
+    {
+      name: "_key",
+      type: "bytes32",
+    },
+    {
+      name: "_value",
+      type: "uint256",
+    },
+  ],
+  name: "set",
+  outputs: [],
+  payable: false,
+  stateMutability: "nonpayable",
+  type: "function",
+};
+
+const get: abi.Function.Definition = {
+  constant: true,
+  inputs: [
+    {
+      name: "_key",
+      type: "bytes32",
+    },
+  ],
+  name: "get",
+  outputs: [
+    {
+      name: "",
+      type: "uint256",
+    },
+  ],
+  payable: false,
+  stateMutability: "view",
+  type: "function",
+};
+
+/**
+ * EVENTS
+ */
+const Set: abi.Event.Definition = {
+  anonymous: false,
+  inputs: [
+    {
+      indexed: true,
+      name: "key",
+      type: "bytes32",
+    },
+    {
+      indexed: false,
+      name: "value",
+      type: "uint256",
+    },
+  ],
+  name: "Set",
+  type: "event",
+};
+
+export default {
+  set: new abi.Function(set),
+  get: new abi.Function(get),
+  Set: new abi.Event(Set),
+};

package/src/contracts/constants.ts

@@ -0,0 +1,11 @@
+export const TransferEventSignature =
+  "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+
+export const VTHO_ADDRESS = "0x0000000000000000000000000000456e65726779";
+
+// params.sol - builtin contract (https://www.vechain.org/whitepaper/#bit_v48i3)
+export const PARAMS_ADDRESS = "0x0000000000000000000000000000506172616d73";
+export const REWARD_RATIO_KEY =
+  "0x00000000000000000000000000000000000000007265776172642d726174696f";
+export const BASE_GAS_PRICE_KEY =
+  "0x000000000000000000000000000000000000626173652d6761732d7072696365";

package/src/datasets/index.ts

@@ -0,0 +1,2 @@
+export * from "./vechain.scanAccounts.1";
+export { vechain1, vechain2, vechain3 } from "./vechain";

package/src/datasets/vechain.scanAccounts.1.ts

@@ -0,0 +1,13 @@
+export default [
+  {
+    name: "vechain seed 1",
+    apdus: `
+      => e002000015058000002c80000332800000000000000000000000
+      <= 4104de5a8f11cc426ff5617aeffd397c5dd77b58424662f368f2cd539a8c42fd2e7d0c6245c9c3a4306f70d7f292e95642651a6832d66fd9823fa6a0af575113e94e28306665363638383534386630433330333933326242313937423041393630333466316437346462619000
+      => e002000015058000002c80000332800000000000000000000001
+      <= 4104c1295d6d253841866b1cf8adbb63004d74849370d6301c839c7f57fa764b2eab0ae8fd4ea092a0ee3c2ca3bc61542b4becae04b5e1ed91e698a4a4d620a512dd28303239363142393242384432304134656131326631663143654641373444643742343335354138369000
+      => e002000015058000002c80000332800000000000000000000002
+      <= 41047ff6eb07f97f5db006f9777d96a44bcb4cd35bf149ff9ed63d9b5fba32e167caa272a2b648e826aa4b9e7c88871d69096424c59634bc260e28fc1c1a3d5f204728466243383635334330623834326464333333363143453839333842323465343037646434383338439000
+      `,
+  },
+];

package/src/datasets/vechain.ts

@@ -0,0 +1,92 @@
+import { AccountRaw } from "@ledgerhq/types-live";
+
+// NOTE: account information is fetched from the blockchain so this is just integration for those information
+// so you you should not rely on that, here the important part are ids and index
+
+export const vechain1: AccountRaw = {
+  id: "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
+  seedIdentifier: "0x0fe6688548f0C303932bB197B0A96034f1d74dba",
+  name: "Vechain 1",
+  derivationMode: "vechain",
+  index: 0,
+  freshAddress: "0x0fe6688548f0C303932bB197B0A96034f1d74dba",
+  freshAddressPath: "44'/818'/0'/0/0",
+  blockHeight: 15156315,
+  operations: [],
+  pendingOperations: [],
+  currencyId: "vechain",
+  feesCurrencyId: "vechain/vip180/vtho",
+  lastSyncDate: "2023-04-21T14:22:48.395Z",
+  balance: "10000000000000000000",
+  subAccounts: [
+    {
+      type: "TokenAccountRaw",
+      id: "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
+      parentId: "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
+      tokenId: "vechain/vip180/vtho",
+      balance: "10000000000000000000",
+      operations: [],
+      pendingOperations: [],
+    },
+  ],
+  swapHistory: [],
+};
+
+export const vechain2: AccountRaw = {
+  id: "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
+  seedIdentifier: "0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86",
+  name: "Vechain 2",
+  derivationMode: "vechain",
+  index: 1,
+  freshAddress: "0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86",
+  freshAddressPath: "44'/818'/0'/0/1",
+  blockHeight: 15156315,
+  operations: [],
+  pendingOperations: [],
+  currencyId: "vechain",
+  feesCurrencyId: "vechain/vip180/vtho",
+  lastSyncDate: "2023-04-21T14:22:48.395Z",
+  balance: "10000000000000000000",
+  subAccounts: [
+    {
+      type: "TokenAccountRaw",
+      id: "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain+vechain%2Fvip180%2Fvtho",
+      parentId: "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
+      tokenId: "vechain/vip180/vtho",
+      balance: "0",
+      operations: [],
+      pendingOperations: [],
+    },
+  ],
+  swapHistory: [],
+};
+
+// account with vtho but no vet
+export const vechain3: AccountRaw = {
+  id: "js:2:vechain:0xC0dFC490f8fba6A573C55a68dd9023f999ccaDA0:vechain",
+  seedIdentifier: "0xC0dFC490f8fba6A573C55a68dd9023f999ccaDA0",
+  name: "Vechain 3",
+  derivationMode: "vechain",
+  index: 1,
+  freshAddress: "0xC0dFC490f8fba6A573C55a68dd9023f999ccaDA0",
+  freshAddressPath: "44'/818'/0'/0/0",
+  blockHeight: 15156315,
+  operations: [],
+  pendingOperations: [],
+  currencyId: "vechain",
+  feesCurrencyId: "vechain/vip180/vtho",
+  lastSyncDate: "2023-11-13T13:55:32.004Z",
+  balance: "0",
+  subAccounts: [
+    {
+      type: "TokenAccountRaw",
+      id: "js:2:vechain:0xC0dFC490f8fba6A573C55a68dd9023f999ccaDA0:vechain+vechain%2Fvip180%2Fvtho",
+      parentId: "js:2:vechain:0xC0dFC490f8fba6A573C55a68dd9023f999ccaDA0:vechain",
+      tokenId: "vechain/vip180/vtho",
+      balance: "1000000000000000",
+      operations: [],
+      pendingOperations: [],
+    },
+  ],
+  swapHistory: [],
+};

package/src/errors.ts

@@ -0,0 +1,7 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const NotEnoughVTHO = createCustomErrorClass("NotEnoughVTHO");
+export const MustBeVechain = createCustomErrorClass("MustBeVechain");
+export const ImpossibleToCalculateAmountAndFees = createCustomErrorClass(
+  "ImpossibleToCalculateAmountAndFees",
+);

package/src/index.ts

@@ -0,0 +1 @@
+export { createBridges } from "./bridge/index";

package/src/mock.ts

@@ -0,0 +1,14 @@
+import type { Account } from "@ledgerhq/types-live";
+
+function postSyncAccount(account: Account): Account {
+  return account;
+}
+
+function postScanAccount(account: Account): Account {
+  return account;
+}
+
+export default {
+  postSyncAccount,
+  postScanAccount,
+};

package/src/network/index.ts

@@ -0,0 +1,2 @@
+export { getAccount, getOperations } from "./sdk";
+export * from "./sdk";

package/src/network/sdk.ts

@@ -0,0 +1,177 @@
+import BigNumber from "bignumber.js";
+import network from "@ledgerhq/live-network/network";
+import { AccountResponse, VetTxsQuery, TokenTxsQuery, Query, QueryResponse } from "../types";
+import type { Operation } from "@ledgerhq/types-live";
+import {
+  mapVetTransfersToOperations,
+  mapTokenTransfersToOperations,
+  padAddress,
+} from "../common-logic";
+import { TransferEventSignature } from "../contracts/constants";
+import { Transaction } from "thor-devkit";
+import { HEX_PREFIX } from "../types";
+import { getEnv } from "@ledgerhq/live-env";
+
+const BASE_URL = getEnv("API_VECHAIN_THOREST");
+
+export const getAccount = async (address: string): Promise<AccountResponse> => {
+  const { data } = await network({
+    method: "GET",
+    url: `${BASE_URL}/accounts/${address}`,
+  });
+
+  return data;
+};
+
+export const getLastBlockHeight = async (): Promise<number> => {
+  const { data } = await network({
+    method: "GET",
+    url: `${BASE_URL}/blocks/best`,
+  });
+
+  return data.number;
+};
+
+/**
+ * Get VET operations
+ * @param accountId
+ * @param addr
+ * @param startAt
+ * @returns an array of operations
+ */
+export const getOperations = async (
+  accountId: string,
+  addr: string,
+  startAt: number,
+): Promise<Operation[]> => {
+  const query: VetTxsQuery = {
+    range: {
+      unit: "block",
+      from: startAt,
+    },
+    criteriaSet: [{ sender: addr }, { recipient: addr }],
+    order: "desc",
+  };
+
+  const { data } = await network({
+    method: "POST",
+    url: `${BASE_URL}/logs/transfer`,
+    data: JSON.stringify(query),
+  });
+
+  const operations: Operation[] = await mapVetTransfersToOperations(data, accountId, addr);
+
+  return operations;
+};
+
+/**
+ * Get operations for a fungible token
+ * @param accountId
+ * @param addr
+ * @param tokenAddr - The token address (The VTHO token address is available from constants.ts)
+ * @param startAt
+ * @returns an array of operations
+ */
+export const getTokenOperations = async (
+  accountId: string,
+  addr: string,
+  tokenAddr: string,
+  startAt: number,
+): Promise<Operation[]> => {
+  const paddedAddress = padAddress(addr);
+
+  const query: TokenTxsQuery = {
+    range: {
+      unit: "block",
+      from: startAt,
+    },
+    criteriaSet: [
+      {
+        address: tokenAddr,
+        topic0: TransferEventSignature,
+        topic1: paddedAddress,
+      },
+      {
+        address: tokenAddr,
+        topic0: TransferEventSignature,
+        topic2: paddedAddress,
+      },
+    ],
+    order: "desc",
+  };
+
+  const { data } = await network({
+    method: "POST",
+    url: `${BASE_URL}/logs/event`,
+    data: JSON.stringify(query),
+  });
+
+  const operations = await mapTokenTransfersToOperations(data, accountId, addr);
+  return operations;
+};
+
+/**
+ * Submit a transaction and return the ID
+ * @param tx - The transaction to submit
+ * @returns transaction ID
+ */
+export const submit = async (tx: Transaction): Promise<string> => {
+  const encodedRawTx = {
+    raw: `${HEX_PREFIX}${tx.encode().toString("hex")}`,
+  };
+
+  const { data } = await network({
+    method: "POST",
+    url: `${BASE_URL}/transactions`,
+    data: encodedRawTx,
+  });
+
+  // Expect a transaction ID
+  if (!data.id) throw Error("Expected an ID to be returned");
+
+  return data.id;
+};
+
+/**
+ * Query the blockchain
+ * @param queryData - The query data
+ * @returns a result of the query
+ */
+export const query = async (queryData: Query[]): Promise<QueryResponse[]> => {
+  const { data } = await network({
+    method: "POST",
+    url: `${BASE_URL}/accounts/*`,
+    data: { clauses: queryData },
+  });
+
+  return data;
+};
+
+/**
+ * Get the block ref to use in a transaction
+ * @returns the block ref of head
+ */
+export const getBlockRef = async (): Promise<string> => {
+  const { data } = await network({
+    method: "GET",
+    url: `${BASE_URL}/blocks/best`,
+  });
+
+  return data.id.slice(0, 18);
+};
+
+/**
+ * Get fees paid for the transaction
+ * @param transactionId - the id of the transaction
+ * @return the fee paid in VTHO or 0
+ */
+export const getFees = async (transactionID: string): Promise<BigNumber> => {
+  const { data } = await network({
+    method: "GET",
+    url: `${BASE_URL}/transactions/${transactionID}/receipt`,
+    params: { id: transactionID },
+  });
+
+  if (!data || !data.paid) return new BigNumber(0);
+  return new BigNumber(data.paid);
+};

package/src/signer/getAddress.ts

@@ -0,0 +1,25 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import eip55 from "eip55";
+import { VechainSigner } from "../types";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+
+const resolver = (signerContext: SignerContext<VechainSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const sig = await signerContext(deviceId, async signer => {
+      return await signer.getAddress(path, verify, false); // Note: Do we need to check askChainCode or false?
+    });
+
+    if (!sig.address || !sig.publicKey.length)
+      throw Error(`[vechain] Response is empty ${sig.address} ${sig.publicKey}`);
+
+    const address = eip55.encode(sig.address);
+    return {
+      address,
+      publicKey: sig.publicKey,
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/signer/index.ts

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