@ledgerhq/coin-tezos 6.6.0-nightly.1 → 6.6.0

package/src/bridge/signOperation.ts

@@ -0,0 +1,130 @@
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { SignOperationEvent, AccountBridge } from "@ledgerhq/types-live";
+import type { TezosAccount, TezosSigner, Transaction, TransactionStatus } from "../types";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { craftTransaction, rawEncode } from "../logic";
+import { getTezosToolkit } from "../logic/tezosToolkit";
+
+// Exported for test purpose only
+export async function getOperationContents({
+  account,
+  transaction,
+  counter,
+  public_key,
+  public_key_hash,
+}: {
+  account: TezosAccount;
+  transaction: Transaction;
+  counter: number;
+  public_key: string;
+  public_key_hash: string;
+}) {
+  let publicKey = undefined;
+  if (!account.tezosResources.revealed) {
+    publicKey = {
+      publicKey: public_key,
+      publicKeyHash: public_key_hash,
+    };
+  }
+
+  return craftTransaction(
+    {
+      address: account.freshAddress,
+      counter,
+    },
+    {
+      type: transaction.mode,
+      recipient: transaction.recipient,
+      amount: BigInt(transaction.amount.toString()),
+      fee: {
+        fees: (transaction.fees || 0).toString(),
+        gasLimit: (transaction.gasLimit || 0).toString(),
+        storageLimit: (transaction.storageLimit || 0).toString(),
+      },
+    },
+    publicKey,
+  );
+}
+
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<TezosSigner>,
+  ): AccountBridge<Transaction, TezosAccount, TransactionStatus>["signOperation"] =>
+  ({ account, deviceId, transaction }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      let cancelled = false;
+
+      async function main() {
+        const { fees } = transaction;
+        if (!fees) throw new FeeNotLoaded();
+
+        const { freshAddressPath, freshAddress } = account;
+
+        const signedInfo = await signerContext(deviceId, async signer => {
+          const ledgerSigner = signer.createLedgerSigner(freshAddressPath, false, 0);
+
+          const tezosToolkit = getTezosToolkit();
+          tezosToolkit.setProvider({ signer: ledgerSigner });
+
+          const publicKey = await ledgerSigner.publicKey();
+          const publicKeyHash = await ledgerSigner.publicKeyHash();
+
+          const sourceData = await tezosToolkit.rpc.getContract(freshAddress);
+
+          o.next({ type: "device-signature-requested" });
+
+          if (cancelled) {
+            return;
+          }
+
+          const { type, contents } = await getOperationContents({
+            account,
+            transaction,
+            counter: Number(sourceData.counter),
+            public_key: publicKey,
+            public_key_hash: publicKeyHash,
+          });
+
+          const forgedBytes = await rawEncode(contents);
+
+          const signature = await ledgerSigner.sign(forgedBytes);
+
+          return {
+            type,
+            signature,
+          };
+        });
+
+        if (!signedInfo) {
+          return;
+        }
+
+        o.next({ type: "device-signature-granted" });
+
+        const { type, signature } = signedInfo;
+        const operation = buildOptimisticOperation(account, transaction, type);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            // we slice the signature to remove the `03` prefix
+            // which souldn't be included in the signature
+            signature: signature.sbytes.slice(2),
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    });
+
+export default buildSignOperation;

package/src/bridge/synchronization.integ.test.ts

@@ -0,0 +1,33 @@
+import coinConfig, { TezosCoinConfig } from "../config";
+import { fetchAllTransactions } from "../network/tzkt";
+import { mockConfig } from "../test/config";
+
+jest.setTimeout(2 * 60 * 1000);
+
+describe("TEZOS_MAX_TX_QUERIES", () => {
+  const tezosConfig = mockConfig as TezosCoinConfig;
+  const bigAccount = "tz1boBHAVpwcvKkNFAQHYr7mjxAz1PpVgKq7";
+
+  test("default have more than 100 txs", async () => {
+    // Given
+    coinConfig.setCoinConfig((): TezosCoinConfig => tezosConfig);
+
+    const txs = await fetchAllTransactions(bigAccount);
+    expect(txs.length).toBeGreaterThan(100);
+  });
+  test("lowering it to 1 will only fetch a few txs", async () => {
+    // Given
+    coinConfig.setCoinConfig(
+      (): TezosCoinConfig => ({
+        ...tezosConfig,
+        explorer: {
+          url: "https://xtz-tzkt-explorer.api.live.ledger.com",
+          maxTxQuery: 1,
+        },
+      }),
+    );
+
+    const txs = await fetchAllTransactions(bigAccount);
+    expect(txs.length).toBeLessThanOrEqual(100);
+  });
+});

package/src/bridge/synchronization.ts

@@ -0,0 +1,100 @@
+import invariant from "invariant";
+import { BigNumber } from "bignumber.js";
+import type { TokenAccount } from "@ledgerhq/types-live";
+import { GetAccountShape, makeSync, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeAccountId, areAllOperationsLoaded } from "@ledgerhq/coin-framework/account/index";
+import { encodeAddress, isStringHex, reconciliatePublicKey, txToOp } from "./logic";
+import api, { fetchAllTransactions } from "../network/tzkt";
+import { TezosAccount, TezosOperation } from "../types";
+
+export const getAccountShape: GetAccountShape<TezosAccount> = async ({
+  initialAccount,
+  rest,
+  currency,
+  derivationMode,
+}) => {
+  const publicKey = reconciliatePublicKey(rest?.publicKey, initialAccount);
+  invariant(
+    isStringHex(publicKey),
+    `Invalid public key (${publicKey}). Please reimport your Tezos accounts`,
+  );
+  const hex = Buffer.from(publicKey, "hex");
+  const address = encodeAddress(hex);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: publicKey,
+    derivationMode,
+  });
+
+  const initialStableOperations = (
+    initialAccount && initialAccount.id === accountId ? initialAccount.operations : []
+  ) as TezosOperation[];
+
+  // fetch transactions, incrementally if possible
+  const mostRecentStableOperation = initialStableOperations[0];
+
+  const lastId =
+    initialAccount && areAllOperationsLoaded(initialAccount) && mostRecentStableOperation
+      ? mostRecentStableOperation.extra.id || undefined
+      : undefined;
+
+  const apiAccountPromise = api.getAccountByAddress(address);
+  const blocksCountPromise = api.getBlockCount();
+
+  const [apiAccount, blockHeight] = await Promise.all([apiAccountPromise, blocksCountPromise]);
+
+  if (apiAccount.type === "empty") {
+    return {
+      id: accountId,
+      xpub: publicKey,
+      freshAddress: address,
+      blockHeight,
+      lastSyncDate: new Date(),
+      tezosResources: {
+        revealed: false,
+        counter: 0,
+      },
+    };
+  }
+
+  const fullySupported = apiAccount.type === "user";
+
+  const apiOperations = fullySupported ? await fetchAllTransactions(address, lastId) : [];
+
+  const { revealed, counter } = apiAccount;
+
+  const tezosResources = {
+    revealed,
+    counter,
+  };
+
+  const balance = new BigNumber(apiAccount.balance);
+  const subAccounts: TokenAccount[] = [];
+
+  const newOps = apiOperations
+    .map(txToOp({ address, accountId }))
+    .filter(Boolean) as unknown as TezosOperation[]; // force cast because `filter(Boolean)` remove undefined and null value
+
+  const operations = mergeOps(initialStableOperations, newOps);
+
+  const accountShape = {
+    id: accountId,
+    xpub: publicKey,
+    freshAddress: address,
+    operations,
+    operationsCount: operations.length,
+    balance,
+    subAccounts,
+    spendableBalance: balance,
+    blockHeight,
+    lastSyncDate: new Date(),
+    tezosResources,
+  };
+
+  return accountShape;
+};
+
+export const sync = makeSync({ getAccountShape });

package/src/{transaction.ts → bridge/transaction.ts}

@@ -1,5 +1,5 @@
 import { BigNumber } from "bignumber.js";
-import type { Transaction, TransactionRaw } from "./types";
+import type { Transaction, TransactionRaw } from "../types";
 import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
 import {
   fromTransactionCommonRaw,
@@ -58,9 +58,9 @@ export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
       fees: new BigNumber(networkInfo.fees),
     },
     fees: tr.fees ? new BigNumber(tr.fees) : null,
-    gasLimit: tr.gasLimit ? new BigNumber(tr.gasLimit) : undefined,
-    storageLimit: tr.storageLimit ? new BigNumber(tr.storageLimit) : undefined,
-    estimatedFees: tr.estimatedFees ? new BigNumber(tr.estimatedFees) : undefined,
+    gasLimit: tr.gasLimit ? new BigNumber(tr.gasLimit) : null,
+    storageLimit: tr.storageLimit ? new BigNumber(tr.storageLimit) : null,
+    estimatedFees: tr.estimatedFees ? new BigNumber(tr.estimatedFees) : null,
     taquitoError: tr.taquitoError,
   };
 };

package/src/config.ts

@@ -1,8 +1,4 @@
-import buildCoinConfig, {
-  type CoinConfig,
-  type CurrencyConfig,
-} from "@ledgerhq/coin-framework/config";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
 
 export type TezosConfig = {
   baker: {
@@ -26,9 +22,6 @@ export type TezosConfig = {
 
 export type TezosCoinConfig = CurrencyConfig & TezosConfig;
 
-const coinConfig: {
-  setCoinConfig: (config: CoinConfig<TezosCoinConfig>) => void;
-  getCoinConfig: (currency?: CryptoCurrency) => TezosCoinConfig;
-} = buildCoinConfig<TezosCoinConfig>();
+const coinConfig = buildCoinConfig<TezosCoinConfig>();
 
 export default coinConfig;

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./types";
-export * from "./transaction";
+
+export { createBridges } from "./bridge/index";

package/src/logic/craftTransaction.test.ts

@@ -21,7 +21,6 @@ describe("craftTransaction", () => {
     estimate: {
       reveal: jest.fn(),
     },
-    setProvider: jest.fn(),
   };
 
   beforeEach(() => {

package/src/logic/craftTransaction.ts

@@ -3,7 +3,6 @@ import { getRevealFee } from "@taquito/taquito";
 import coinConfig from "../config";
 import { UnsupportedTransactionMode } from "../types/errors";
 import { getTezosToolkit } from "./tezosToolkit";
-import { createMockSigner } from "../utils";
 
 export type TransactionFee = {
   fees?: string;
@@ -38,13 +37,6 @@ export async function craftTransaction(
 
   const tezosToolkit = getTezosToolkit();
 
-  // Configure signer for Taquito operations (same as in estimateFees)
-  if (publicKey) {
-    tezosToolkit.setProvider({
-      signer: createMockSigner(publicKey.publicKeyHash, publicKey.publicKey),
-    });
-  }
-
   const sourceData = await tezosToolkit.rpc.getContract(address);
   const counter = account.counter ?? Number(sourceData.counter);
 

package/src/logic/estimateFees.integ.test.ts

@@ -22,10 +22,7 @@ describe("estimateFees", () => {
     },
   ];
 
-  it.each([
-    [accounts[0], "with xpub"],
-    [accounts[1], "without xpub"],
-  ])("returns correct value %s", async (account, _description) => {
+  it.each(accounts)("returns correct value", async account => {
     // Given
     const transaction = {
       mode: "send",
@@ -45,10 +42,7 @@ describe("estimateFees", () => {
     });
   });
 
-  it.each([
-    [accounts[0], "with xpub"],
-    [accounts[1], "without xpub"],
-  ])("returns correct value when useAllAmount %s", async (account, _description) => {
+  it.each(accounts)("returns correct value when useAllAmount", async account => {
     // Given
     const transaction = {
       mode: "send",

package/src/logic/estimateFees.ts

@@ -1,17 +1,11 @@
+import { DerivationType } from "@taquito/ledger-signer";
+import { compressPublicKey } from "@taquito/ledger-signer/dist/lib/utils";
 import { COST_PER_BYTE, getRevealFee, ORIGINATION_SIZE, Estimate } from "@taquito/taquito";
-import { validatePublicKey, ValidationResult } from "@taquito/utils";
+import { b58Encode, PrefixV2 } from "@taquito/utils";
 import { log } from "@ledgerhq/logs";
 import { getTezosToolkit } from "./tezosToolkit";
 import { TezosOperationMode } from "../types/model";
 import { UnsupportedTransactionMode } from "../types/errors";
-import {
-  createFallbackEstimation,
-  createMockSigner,
-  DUST_MARGIN_MUTEZ,
-  MIN_SUGGESTED_FEE_SMALL_TRANSFER,
-  OP_SIZE_XTZ_TRANSFER,
-  normalizePublicKeyForAddress,
-} from "../utils";
 
 export type CoreAccountInfo = {
   address: string;
@@ -47,43 +41,54 @@ export async function estimateFees({
   account: CoreAccountInfo;
   transaction: CoreTransactionInfo;
 }): Promise<EstimatedFees> {
-  // Normalize public key (hex -> base58) when provided (may be undefined for unrevealed accounts)
-  // before the device is connected
-  const encodedPubKey = account.xpub
-    ? normalizePublicKeyForAddress(account.xpub, account.address)
-    : undefined;
-
-  const tezosToolkit = getTezosToolkit();
-  if (encodedPubKey && validatePublicKey(encodedPubKey) === ValidationResult.VALID) {
-    tezosToolkit.setProvider({ signer: createMockSigner(account.address, encodedPubKey) });
+  let derivationType: DerivationType;
+  let prefix: PrefixV2;
+  if (account.address?.startsWith("tz1")) {
+    derivationType = DerivationType.ED25519;
+    prefix = PrefixV2.Ed25519PublicKey;
+  } else if (account.address?.startsWith("tz2")) {
+    derivationType = DerivationType.SECP256K1;
+    prefix = PrefixV2.Secp256k1PublicKey;
+  } else if (account.address?.startsWith("tz3")) {
+    derivationType = DerivationType.P256;
+    prefix = PrefixV2.P256PublicKey;
   } else {
-    tezosToolkit.setProvider({ signer: createMockSigner(account.address, "") });
+    throw Error(`Failed detecting key derivation type from address ${account.address}`);
   }
 
+  const encodedPubKey = b58Encode(
+    compressPublicKey(Buffer.from(account.xpub || "", "hex"), derivationType),
+    prefix,
+  );
+
+  const tezosToolkit = getTezosToolkit();
+  tezosToolkit.setProvider({
+    signer: {
+      publicKeyHash: async () => account.address,
+      publicKey: async () => encodedPubKey,
+      sign: () => Promise.reject(new Error("unsupported")),
+      secretKey: () => Promise.reject(new Error("unsupported")),
+    },
+  });
+
   const estimation: EstimatedFees = {
-    fees: 0n,
-    gasLimit: 0n,
-    storageLimit: 0n,
-    estimatedFees: 0n,
+    fees: BigInt(0),
+    gasLimit: BigInt(0),
+    storageLimit: BigInt(0),
+    estimatedFees: BigInt(0),
   };
 
   // For legacy compatibility
-  if (account.balance === 0n) {
-    return transaction.useAllAmount ? { ...estimation, amount: 0n } : estimation;
+  if (account.balance === BigInt(0)) {
+    return transaction.useAllAmount ? { ...estimation, amount: BigInt(0) } : estimation;
   }
 
   let amount = transaction.amount;
-  if (transaction.useAllAmount || amount === 0n) {
-    amount = 1n; // send max do a pre-estimation with minimum amount (taquito refuses 0)
+  if (transaction.useAllAmount) {
+    amount = BigInt(1); // send max do a pre-estimation with minimum amount (taquito refuses 0)
   }
 
   try {
-    if (transaction.mode === "send" && !transaction.recipient) {
-      return {
-        ...estimation,
-        ...createFallbackEstimation(),
-      };
-    }
     let estimate: Estimate;
     switch (transaction.mode) {
       case "send":
@@ -91,7 +96,6 @@ export async function estimateFees({
           mutez: true,
           to: transaction.recipient,
           amount: Number(amount),
-          source: account.address, // avoid requiring signer for estimation
           storageLimit: ORIGINATION_SIZE, // https://github.com/TezTech/eztz/blob/master/PROTO_003_FEES.md for originating an account
         });
         break;
@@ -125,14 +129,16 @@ export async function estimateFees({
       // NOTE: from https://github.com/ecadlabs/taquito/blob/a70c64c4b105381bb9f1d04c9c70e8ef26e9241c/integration-tests/contract-empty-implicit-account-into-new-implicit-account.spec.ts#L33
       // Temporary fix, see https://gitlab.com/tezos/tezos/-/issues/1754
       // we need to increase the gasLimit and fee returned by the estimation
+      const gasBuffer = 500;
       const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
       const increasedFee = (gasBuffer: number, opSize: number) => {
         return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
       };
-      const incr = increasedFee(DUST_MARGIN_MUTEZ, Number(estimate.opSize));
+      const incr = increasedFee(gasBuffer, Number(estimate.opSize));
+
+      const maxMinusBuff = maxAmount - (gasBuffer - incr);
+      estimation.amount = maxMinusBuff > 0 ? BigInt(maxMinusBuff) : BigInt(0);
 
-      const maxMinusBuff = maxAmount - (DUST_MARGIN_MUTEZ - incr);
-      estimation.amount = maxMinusBuff > 0 ? BigInt(maxMinusBuff) : 0n;
       estimation.fees = BigInt(estimate.suggestedFeeMutez);
       estimation.gasLimit = BigInt(estimate.gasLimit);
     } else {
@@ -140,7 +146,6 @@ export async function estimateFees({
       estimation.gasLimit = BigInt(estimate.gasLimit);
       estimation.amount = transaction.amount;
     }
-
     estimation.storageLimit = BigInt(estimate.storageLimit);
     estimation.estimatedFees = estimation.fees;
     if (!account.revealed) {
@@ -152,109 +157,13 @@ export async function estimateFees({
       estimation.taquitoError = (e as { id: string }).id;
       log("taquito-error", "taquito got error " + e.id);
     } else if ("status" in e) {
-      const errorMessage = String((e as unknown as { message: string }).message || "");
-      if (
-        errorMessage.includes("Public key not found") ||
-        errorMessage.includes("wallet or contract API")
-      ) {
-        log(
-          "taquito-network-error",
-          "Recipient address not found (new account), using default fees",
-          {
-            transaction: transaction,
-          },
-        );
-        const fallback = createFallbackEstimation();
-        estimation.fees = fallback.fees;
-        estimation.gasLimit = fallback.gasLimit;
-        estimation.storageLimit = fallback.storageLimit;
-        estimation.estimatedFees = fallback.fees;
-        if (!account.revealed) {
-          estimation.estimatedFees =
-            estimation.estimatedFees + BigInt(getRevealFee(account.address));
-        }
-        // Handle useAllAmount also for send mode when estimation falls back
-        if (transaction.useAllAmount) {
-          // Approximate Taquito behavior for send-max using stable constants
-          const suggestedFee =
-            transaction.mode === "send"
-              ? MIN_SUGGESTED_FEE_SMALL_TRANSFER
-              : Number(estimation.fees);
-
-          // For display consistency in tests, align fees to suggestedFee in send-max
-          if (transaction.mode === "send") {
-            estimation.fees = BigInt(suggestedFee);
-            estimation.estimatedFees = BigInt(suggestedFee);
-            if (!account.revealed) {
-              estimation.estimatedFees =
-                estimation.estimatedFees + BigInt(getRevealFee(account.address));
-            }
-          }
-
-          const burnFeeMutez = Number(estimation.storageLimit) * COST_PER_BYTE;
-          const totalFees =
-            suggestedFee + (burnFeeMutez > 0 ? burnFeeMutez - 20 * COST_PER_BYTE : 0);
-
-          const revealFee = account.revealed ? 0 : getRevealFee(account.address);
-          const maxAmount = Number.parseInt(account.balance.toString()) - (totalFees + revealFee);
-
-          const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
-          const incr = OP_SIZE_XTZ_TRANSFER + DUST_MARGIN_MUTEZ * MINIMAL_FEE_PER_GAS_MUTEZ;
-          const maxMinusBuff = maxAmount - (DUST_MARGIN_MUTEZ - incr);
-          estimation.amount = maxMinusBuff > 0 ? BigInt(Math.floor(maxMinusBuff)) : 0n;
-        } else {
-          // preserve input amount in fallback for readability/tests
-          estimation.amount = transaction.amount;
-        }
-      } else {
-        log("taquito-network-error", errorMessage, {
-          transaction: transaction,
-        });
-        throw e;
-      }
+      // in case of http 400, log & ignore (more case to handle)
+      log("taquito-network-error", String((e as unknown as { message: string }).message || ""), {
+        transaction: transaction,
+      });
+      throw e;
     } else {
-      const msg = String((e as any).message || "");
-      if (msg.includes("No signer has been configured")) {
-        const fallback = createFallbackEstimation();
-        estimation.fees = fallback.fees;
-        estimation.gasLimit = fallback.gasLimit;
-        estimation.storageLimit = fallback.storageLimit;
-        estimation.estimatedFees = fallback.estimatedFees;
-        if (!account.revealed) {
-          estimation.estimatedFees =
-            estimation.estimatedFees + BigInt(getRevealFee(account.address));
-        }
-        if (transaction.useAllAmount) {
-          const suggestedFee =
-            transaction.mode === "send"
-              ? MIN_SUGGESTED_FEE_SMALL_TRANSFER
-              : Number(estimation.fees);
-
-          if (transaction.mode === "send") {
-            estimation.fees = BigInt(suggestedFee);
-            estimation.estimatedFees = BigInt(suggestedFee);
-            if (!account.revealed) {
-              estimation.estimatedFees =
-                estimation.estimatedFees + BigInt(getRevealFee(account.address));
-            }
-          }
-
-          const burnFeeMutez = Number(estimation.storageLimit) * COST_PER_BYTE;
-          const totalFees =
-            suggestedFee + (burnFeeMutez > 0 ? burnFeeMutez - 20 * COST_PER_BYTE : 0);
-          const revealFee = account.revealed ? 0 : getRevealFee(account.address);
-          const maxAmount = Number.parseInt(account.balance.toString()) - (totalFees + revealFee);
-          const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
-          const incr = OP_SIZE_XTZ_TRANSFER + DUST_MARGIN_MUTEZ * MINIMAL_FEE_PER_GAS_MUTEZ;
-          const maxMinusBuff = maxAmount - (DUST_MARGIN_MUTEZ - incr);
-          estimation.amount = maxMinusBuff > 0 ? BigInt(Math.floor(maxMinusBuff)) : 0n;
-        } else {
-          // preserve input amount in fallback for readability/tests
-          estimation.amount = transaction.amount;
-        }
-      } else {
-        throw e;
-      }
+      throw e;
     }
   }
   return estimation;

package/src/logic/getBalance.ts

@@ -6,5 +6,5 @@ import api from "../network/tzkt";
  */
 export async function getBalance(address: string): Promise<bigint> {
   const apiAccount = await api.getAccountByAddress(address);
-  return apiAccount.type === "user" ? BigInt(apiAccount.balance) : -1n;
+  return apiAccount.type === "user" ? BigInt(apiAccount.balance) : BigInt(-1);
 }

package/src/logic/index.ts

@@ -7,5 +7,3 @@ export { estimateFees } from "./estimateFees";
 export { getBalance } from "./getBalance";
 export { lastBlock } from "./lastBlock";
 export { listOperations } from "./listOperations";
-export { validateIntent } from "./validateIntent";
-export { getStakes } from "./getStakes";