Bugfix/tx history restore bump

@shared/api/internal.ts

@@ -1,6 +1,12 @@
 import StellarSdk from "stellar-sdk";
 import * as SorobanClient from "soroban-client";
 import { DataProvider } from "@stellar/wallet-sdk";
+import {
+  getBalance,
+  getDecimals,
+  getName,
+  getSymbol,
+} from "@shared/helpers/soroban/token";
 import {
   Account,
   AccountBalancesInterface,
@@ -24,8 +30,6 @@ import { getIconUrlFromIssuer } from "./helpers/getIconUrlFromIssuer";
 import { getDomainFromIssuer } from "./helpers/getDomainFromIssuer";
 import { stellarSdkServer } from "./helpers/stellarSdkServer";
 
-import { decodei128, decodeU32, decodeStr } from "./helpers/soroban";
-
 const TRANSACTIONS_LIMIT = 100;
 
 export const createAccount = async (
@@ -859,94 +863,37 @@ export const getBlockedAccounts = async () => {
   return resp;
 };
 
-type TxToOp = {
-  [index: string]: {
-    tx: SorobanClient.Transaction<
-      SorobanClient.Memo<SorobanClient.MemoType>,
-      SorobanClient.Operation[]
-    >;
-    decoder: (xdr: string) => string | number;
-  };
-};
-
-interface SorobanTokenRecord {
-  [key: string]: unknown;
-  balance: number;
-  name: string;
-  symbol: string;
-  decimals: string;
-}
-
-export const getSorobanTokenBalance = (
+export const getSorobanTokenBalance = async (
   server: SorobanClient.Server,
   contractId: string,
   txBuilders: {
-    // need a builder per operation until multi-op transactions are released
+    // need a builder per operation, Soroban currently has single op transactions
     balance: SorobanClient.TransactionBuilder;
     name: SorobanClient.TransactionBuilder;
     decimals: SorobanClient.TransactionBuilder;
     symbol: SorobanClient.TransactionBuilder;
   },
-  params: SorobanClient.xdr.ScVal[],
+  balanceParams: SorobanClient.xdr.ScVal[],
 ) => {
-  const contract = new SorobanClient.Contract(contractId);
-
   // Right now we can only have 1 operation per TX in Soroban
-  // There is ongoing work to lift this restriction
-  // but for now we need to do 4 txs to show 1 user balance. :(
-  const balanceTx = txBuilders.balance
-    .addOperation(contract.call("balance", ...params))
-    .setTimeout(SorobanClient.TimeoutInfinite)
-    .build();
-
-  const nameTx = txBuilders.name
-    .addOperation(contract.call("name"))
-    .setTimeout(SorobanClient.TimeoutInfinite)
-    .build();
-
-  const symbolTx = txBuilders.symbol
-    .addOperation(contract.call("symbol"))
-    .setTimeout(SorobanClient.TimeoutInfinite)
-    .build();
-
-  const decimalsTx = txBuilders.decimals
-    .addOperation(contract.call("decimals"))
-    .setTimeout(SorobanClient.TimeoutInfinite)
-    .build();
-
-  const txs: TxToOp = {
-    balance: {
-      tx: balanceTx,
-      decoder: decodei128,
-    },
-    name: {
-      tx: nameTx,
-      decoder: decodeStr,
-    },
-    symbol: {
-      tx: symbolTx,
-      decoder: decodeStr,
-    },
-    decimals: {
-      tx: decimalsTx,
-      decoder: decodeU32,
-    },
-  };
-
-  const tokenBalanceInfo = Object.keys(txs).reduce(async (prev, curr) => {
-    const _prev = await prev;
-    const { tx, decoder } = txs[curr];
-    const { results } = await server.simulateTransaction(tx);
-    if (!results || results.length !== 1) {
-      throw new Error("Invalid response from simulateTransaction");
-    }
-    const result = results[0];
-    _prev[curr] = decoder(result.xdr);
-
-    return _prev;
-  }, Promise.resolve({} as SorobanTokenRecord));
+  // for now we need to do 4 tx simulations to show 1 user balance. :(
+  // TODO: figure out how to fetch ledger keys to do this more efficiently
+  const decimals = await getDecimals(contractId, server, txBuilders.decimals);
+  const name = await getName(contractId, server, txBuilders.name);
+  const symbol = await getSymbol(contractId, server, txBuilders.symbol);
+  const balance = await getBalance(
+    contractId,
+    balanceParams,
+    server,
+    txBuilders.balance,
+  );
 
-  return tokenBalanceInfo;
+  return {
+    balance,
+    decimals,
+    name,
+    symbol,
+  };
 };
 
 export const addTokenId = async (

@shared/api/types.ts

@@ -148,7 +148,7 @@ export interface SorobanBalance {
   total: BigNumber;
   name: string;
   symbol: string;
-  decimals: string;
+  decimals: number;
 }
 
 export type AssetType =

@shared/constants/soroban/token.ts

@@ -0,0 +1,17 @@
+// https://github.com/stellar/soroban-examples/blob/main/token/src/contract.rs
+export enum SorobanTokenInterface {
+  transfer = "transfer",
+  mint = "mint",
+}
+
+// TODO: can we generate this at build time using the cli TS generator? Also should we?
+export interface SorobanToken {
+  // only currently holds fields we care about
+  transfer: (from: string, to: string, amount: number) => void;
+  mint: (to: string, amount: number) => void;
+  // values below are in storage
+  name: string;
+  balance: number;
+  symbol: string;
+  decimals: number;
+}

@shared/helpers/soroban/server.ts

@@ -0,0 +1,32 @@
+import {
+  Transaction,
+  Memo,
+  MemoType,
+  Operation,
+  Server,
+  xdr,
+  scValToNative,
+} from "soroban-client";
+import { captureException } from "@sentry/browser";
+
+export const simulateTx = async <ArgType>(
+  tx: Transaction<Memo<MemoType>, Operation[]>,
+  server: Server,
+): Promise<ArgType> => {
+  const { results } = await server.simulateTransaction(tx);
+  if (!results || results.length !== 1) {
+    throw new Error("Invalid response from simulateTransaction");
+  }
+  const result = results[0];
+  const scVal = xdr.ScVal.fromXDR(result.xdr, "base64");
+  let convertedScVal: any;
+  try {
+    // handle a case where scValToNative doesn't properly handle scvString
+    convertedScVal = scVal.str().toString();
+    return convertedScVal;
+  } catch (e) {
+    console.error(e);
+    captureException(`Failed to convert SCVal to native val, ${e}`);
+  }
+  return scValToNative(scVal);
+};

@shared/helpers/soroban/token.ts

@@ -0,0 +1,93 @@
+import {
+  Contract,
+  TransactionBuilder,
+  Memo,
+  Server,
+  TimeoutInfinite,
+  xdr,
+} from "soroban-client";
+import { simulateTx } from "./server";
+
+export const transfer = async (
+  contractId: string,
+  params: xdr.ScVal[],
+  memo: string | undefined,
+  builder: TransactionBuilder,
+) => {
+  const contract = new Contract(contractId);
+
+  const tx = builder
+    .addOperation(contract.call("transfer", ...params))
+    .setTimeout(TimeoutInfinite);
+
+  if (memo) {
+    tx.addMemo(Memo.text(memo));
+  }
+
+  return tx.build();
+};
+
+export const getBalance = async (
+  contractId: string,
+  params: xdr.ScVal[],
+  server: Server,
+  builder: TransactionBuilder,
+) => {
+  const contract = new Contract(contractId);
+
+  const tx = builder
+    .addOperation(contract.call("balance", ...params))
+    .setTimeout(TimeoutInfinite)
+    .build();
+
+  const result = await simulateTx<number>(tx, server);
+  return result;
+};
+
+export const getDecimals = async (
+  contractId: string,
+  server: Server,
+  builder: TransactionBuilder,
+) => {
+  const contract = new Contract(contractId);
+
+  const tx = builder
+    .addOperation(contract.call("decimals"))
+    .setTimeout(TimeoutInfinite)
+    .build();
+
+  const result = await simulateTx<number>(tx, server);
+  return result;
+};
+
+export const getName = async (
+  contractId: string,
+  server: Server,
+  builder: TransactionBuilder,
+) => {
+  const contract = new Contract(contractId);
+
+  const tx = builder
+    .addOperation(contract.call("name"))
+    .setTimeout(TimeoutInfinite)
+    .build();
+
+  const result = await simulateTx<string>(tx, server);
+  return result;
+};
+
+export const getSymbol = async (
+  contractId: string,
+  server: Server,
+  builder: TransactionBuilder,
+) => {
+  const contract = new Contract(contractId);
+
+  const tx = builder
+    .addOperation(contract.call("symbol"))
+    .setTimeout(TimeoutInfinite)
+    .build();
+
+  const result = await simulateTx<string>(tx, server);
+  return result;
+};

extension/src/constants/transaction.ts

@@ -28,6 +28,7 @@ export enum OPERATION_TYPES {
   revokeTrustlineSponsorship = "Revoke Trustline Sponsorship",
   setOptions = "Set Options",
   setTrustLineFlags = "Set Trustline Flags",
+  bumpFootprintExpiration = "Bump Footprint Expiration",
 }
 
 export enum TRANSACTION_WARNING {

extension/src/popup/SorobanContext.tsx

@@ -9,9 +9,11 @@ import {
 
 import { settingsNetworkDetailsSelector } from "./ducks/settings";
 
+const BASE_FEE = "100";
+
 export interface SorobanContextInterface {
   server: SorobanClient.Server;
-  newTxBuilder: () => SorobanClient.TransactionBuilder;
+  newTxBuilder: (fee?: string) => SorobanClient.TransactionBuilder;
 }
 
 export const SorobanContext = React.createContext(
@@ -25,9 +27,6 @@ export const SorobanProvider = ({
   children: React.ReactNode;
   pubKey: string;
 }) => {
-  // Were only simluating so the fee here should not matter
-  // AFAIK there is no fee stats for Soroban yet either
-  const fee = "100";
   const networkDetails = useSelector(settingsNetworkDetailsSelector);
   const source = new SorobanClient.Account(pubKey, "0");
 
@@ -42,7 +41,7 @@ export const SorobanProvider = ({
     allowHttp: networkDetails.networkUrl.startsWith("http://"),
   });
 
-  const newTxBuilder = () =>
+  const newTxBuilder = (fee = BASE_FEE) =>
     new SorobanClient.TransactionBuilder(source, {
       fee,
       networkPassphrase: networkDetails.networkPassphrase,