Merge a40f406 into 581d644

Author: piyalbasu

.gitignore

@@ -11,6 +11,7 @@ node_modules
 
 # production
 */**/build
+*/**/build.zip
 */**/.docusaurus
 
 # misc

@shared/api/helpers/soroban.ts

@@ -0,0 +1,25 @@
+import { xdr, Address } from "soroban-client";
+
+export function accountIdentifier(account: string) {
+  return new Address(account).toScVal();
+}
+
+// How do we decode these in a more generic way?
+export function decodeAccountIdentifier(scVal: Buffer) {
+  const accountId = xdr.ScVal.fromXDR(scVal);
+  const val = accountId.value() as xdr.ScObject;
+  const hyper = val.value() as xdr.Int128Parts;
+  return hyper.lo().low;
+}
+
+export function decodeBytesN(scVal: Buffer) {
+  const val = xdr.ScVal.fromXDR(scVal);
+  const scObj = val.value() as xdr.ScObject;
+  const valBuffer = scObj.value();
+  return valBuffer.toString();
+}
+
+export function decodeScVal(scVal: Buffer) {
+  const val = xdr.ScVal.fromXDR(scVal);
+  return val.value()?.toString() || "";
+}

@shared/api/internal.ts

@@ -1,4 +1,5 @@
 import StellarSdk from "stellar-sdk";
+import * as SorobanClient from "soroban-client";
 import { DataProvider } from "@stellar/wallet-sdk";
 import {
   Account,
@@ -21,6 +22,12 @@ import { getIconUrlFromIssuer } from "./helpers/getIconUrlFromIssuer";
 import { getDomainFromIssuer } from "./helpers/getDomainFromIssuer";
 import { stellarSdkServer } from "./helpers/stellarSdkServer";
 
+import {
+  decodeAccountIdentifier,
+  decodeScVal,
+  decodeBytesN,
+} from "./helpers/soroban";
+
 const TRANSACTIONS_LIMIT = 100;
 
 export const createAccount = async (
@@ -175,6 +182,7 @@ export const loadAccount = (): Promise<{
   applicationState: APPLICATION_STATE;
   allAccounts: Array<Account>;
   bipPath: string;
+  tokenIdList: string[];
 }> =>
   sendMessageToBackground({
     type: SERVICE_TYPES.LOAD_ACCOUNT,
@@ -736,3 +744,124 @@ export const getBlockedDomains = async () => {
   });
   return resp;
 };
+
+type TxToOp = {
+  [index: string]: {
+    tx: SorobanClient.Transaction<
+      SorobanClient.Memo<SorobanClient.MemoType>,
+      SorobanClient.Operation[]
+    >;
+    decoder: (val: Buffer) => string | number;
+  };
+};
+
+interface SorobanTokenRecord {
+  [key: string]: unknown;
+  balance: number;
+  name: string;
+  symbol: string;
+  decimals: string;
+}
+
+export const getSorobanTokenBalance = async (
+  server: SorobanClient.Server,
+  contractId: string,
+  txBuilders: {
+    // need a builder per operation until multi-op transactions are released
+    balance: SorobanClient.TransactionBuilder;
+    name: SorobanClient.TransactionBuilder;
+    decimals: SorobanClient.TransactionBuilder;
+    symbol: SorobanClient.TransactionBuilder;
+  },
+  params: 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: decodeAccountIdentifier,
+    },
+    name: {
+      tx: nameTx,
+      decoder: decodeBytesN,
+    },
+    symbol: {
+      tx: symbolTx,
+      decoder: decodeBytesN,
+    },
+    decimals: {
+      tx: decimalsTx,
+      decoder: decodeScVal,
+    },
+  };
+
+  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(Buffer.from(result.xdr, "base64"));
+
+    return _prev;
+  }, Promise.resolve({} as SorobanTokenRecord));
+
+  return tokenBalanceInfo;
+};
+
+export const addTokenId = async (
+  tokenId: string,
+): Promise<{
+  tokenIdList: string[];
+}> => {
+  let error = "";
+  let tokenIdList = [] as string[];
+
+  try {
+    ({ tokenIdList, error } = await sendMessageToBackground({
+      tokenId,
+      type: SERVICE_TYPES.ADD_TOKEN_ID,
+    }));
+  } catch (e) {
+    console.error(e);
+  }
+
+  if (error) {
+    throw new Error(error);
+  }
+
+  return { tokenIdList };
+};
+
+export const getTokenIds = async (): Promise<string[]> => {
+  const resp = await sendMessageToBackground({
+    type: SERVICE_TYPES.GET_TOKEN_IDS,
+  });
+  return resp.tokenIdList;
+};

@shared/api/types.ts

@@ -6,6 +6,13 @@ import { APPLICATION_STATE } from "../constants/applicationState";
 import { WalletType } from "../constants/hardwareWallet";
 import { NetworkDetails } from "../constants/stellar";
 
+export enum ActionStatus {
+  IDLE = "IDLE",
+  PENDING = "PENDING",
+  SUCCESS = "SUCCESS",
+  ERROR = "ERROR",
+}
+
 export interface Response {
   error: string;
   messagedId: number;
@@ -48,6 +55,8 @@ export interface Response {
   bipPath: string;
   blockedDomains: BlockedDomains;
   assetDomain: string;
+  tokenId: string;
+  tokenIdList: string[];
 }
 
 export interface BlockedDomains {
@@ -101,6 +110,16 @@ export interface AssetDomains {
 
 export type Balances = Types.BalanceMap | null;
 
+export interface SorobanBalance {
+  contractId: string;
+  total: unknown; // BigNumber
+  name: string;
+  symbol: string;
+  decimals: string;
+}
+
+export type TokenBalances = SorobanBalance[];
+
 /* eslint-disable camelcase */
 export type HorizonOperation = any;
 /* eslint-enable camelcase */

@shared/constants/services.ts

@@ -33,6 +33,8 @@ export enum SERVICE_TYPES {
   REMOVE_CUSTOM_NETWORK = "REMOVE_CUSTOM_NETWORK",
   EDIT_CUSTOM_NETWORK = "EDIT_CUSTOM_NETWORK",
   RESET_EXP_DATA = "RESET_EXP_DATA",
+  ADD_TOKEN_ID = "ADD_TOKEN_ID",
+  GET_TOKEN_IDS = "GET_TOKEN_IDS",
 }
 
 export enum EXTERNAL_SERVICE_TYPES {

@shared/constants/stellar.ts

@@ -47,3 +47,7 @@ export const DEFAULT_NETWORKS: Array<NetworkDetails> = [
   MAINNET_NETWORK_DETAILS,
   TESTNET_NETWORK_DETAILS,
 ];
+
+export const SOROBAN_RPC_URLS = {
+  futureNet: "https://stellar-futurenet.4d63.com/soroban/rpc",
+};

extension/package.json

@@ -81,4 +81,4 @@
     "webextension-polyfill-ts": "^0.19.0",
     "yup": "^0.29.1"
   }
-}
+}

extension/public/static/manifest.json

@@ -10,19 +10,13 @@
     }
   },
   "background": {
-    "scripts": [
-      "background.min.js"
-    ],
+    "scripts": ["background.min.js"],
     "persistent": true
   },
   "content_scripts": [
     {
-      "matches": [
-        "<all_urls>"
-      ],
-      "js": [
-        "contentScript.min.js"
-      ],
+      "matches": ["<all_urls>"],
+      "js": ["contentScript.min.js"],
       "run_at": "document_start"
     }
   ],
@@ -41,8 +35,6 @@
     "48": "images/icon48.png",
     "128": "images/icon128.png"
   },
-  "permissions": [
-    "storage"
-  ],
+  "permissions": ["storage"],
   "manifest_version": 2
-}
+}

extension/src/background/messageListener/popupMessageListener.ts

@@ -32,6 +32,7 @@ import {
   CACHED_BLOCKED_DOMAINS_ID,
   NETWORK_ID,
   NETWORKS_LIST_ID,
+  TOKEN_ID_LIST,
 } from "constants/localStorageTypes";
 import {
   FUTURENET_NETWORK_DETAILS,
@@ -568,6 +569,9 @@ export const popupMessageListener = (request: Request) => {
       applicationState: (await dataStorageAccess.getItem(APPLICATION_ID)) || "",
       allAccounts: allAccountsSelector(currentState),
       bipPath: await getBipPath(),
+      tokenIdList: JSON.parse(
+        (await dataStorageAccess.getItem(TOKEN_ID_LIST)) || "[]",
+      ),
     };
   };
 
@@ -1110,6 +1114,40 @@ export const popupMessageListener = (request: Request) => {
     return {};
   };
 
+  const addTokenId = async () => {
+    const { tokenId } = request;
+    const tokenIdList = JSON.parse(
+      (await dataStorageAccess.getItem(TOKEN_ID_LIST)) || "{}",
+    );
+    const keyId = (await dataStorageAccess.getItem(KEY_ID)) || "";
+
+    const accountTokenIdList = tokenIdList[keyId] || [];
+
+    if (accountTokenIdList.includes(tokenId)) {
+      return { error: "Token ID already exists" };
+    }
+
+    accountTokenIdList.push(tokenId);
+    await dataStorageAccess.setItem(
+      TOKEN_ID_LIST,
+      JSON.stringify({
+        ...tokenIdList,
+        [keyId]: accountTokenIdList,
+      }),
+    );
+
+    return { accountTokenIdList };
+  };
+
+  const getTokenIds = async () => {
+    const tokenIdList = JSON.parse(
+      (await dataStorageAccess.getItem(TOKEN_ID_LIST)) || "{}",
+    );
+    const keyId = (await dataStorageAccess.getItem(KEY_ID)) || "";
+
+    return { tokenIdList: tokenIdList[keyId] || [] };
+  };
+
   const messageResponder: MessageResponder = {
     [SERVICE_TYPES.CREATE_ACCOUNT]: createAccount,
     [SERVICE_TYPES.FUND_ACCOUNT]: fundAccount,
@@ -1145,6 +1183,8 @@ export const popupMessageListener = (request: Request) => {
     [SERVICE_TYPES.CACHE_ASSET_DOMAIN]: cacheAssetDomain,
     [SERVICE_TYPES.GET_BLOCKED_DOMAINS]: getBlockedDomains,
     [SERVICE_TYPES.RESET_EXP_DATA]: resetExperimentalData,
+    [SERVICE_TYPES.ADD_TOKEN_ID]: addTokenId,
+    [SERVICE_TYPES.GET_TOKEN_IDS]: getTokenIds,
   };
 
   return messageResponder[request.type]();

extension/src/constants/localStorageTypes.ts

@@ -17,3 +17,4 @@ export const RECENT_ADDRESSES = "recentAddresses";
 export const NETWORK_ID = "network";
 export const NETWORKS_LIST_ID = "networksList";
 export const METRICS_DATA = "metricsData";
+export const TOKEN_ID_LIST = "tokenIdList";