feat: kadena provider changes

packages/extension/package.json

@@ -4,14 +4,16 @@
   "private": true,
   "scripts": {
     "zip": "cd dist; zip -r release.zip *;",
-    "build:chrome": "cross-env BROWSER='chrome' vue-cli-service build && yarn build:rollup",
-    "build:firefox": "cross-env BROWSER='firefox' vue-cli-service build && yarn build:rollup && node configs/get-system-info.js",
+    "prebuild": "yarn kadena:prebuild",
+    "build:chrome": "yarn prebuild && cross-env BROWSER='chrome' vue-cli-service build && yarn build:rollup",
+    "build:firefox": "yarn prebuild && cross-env BROWSER='firefox' vue-cli-service build && yarn build:rollup && node configs/get-system-info.js",
     "lint": "vue-cli-service lint --fix",
     "build:rollup": "cross-env minify=on rollup --config configs/rollup.config.contentscript.mjs && cross-env minify=on rollup --config configs/rollup.config.inject.mjs",
     "inspectWebpack": "vue-cli-service inspect > webpack.log",
+    "kadena:prebuild": "pactjs contract-generate --contract=coin --api https://api.chainweb.com/chainweb/0.0/mainnet01/chain/1/pact",
     "test": "ts-mocha --require ./configs/testNullCompiler.js --paths -p configs/tsconfig.test.json ./**/*.mocha.ts",
-    "watch": "rimraf dist && concurrently 'npm:watch-*(!firefox)'",
-    "watch:firefox": "concurrently 'npm:watch-*(!chrome)'",
+    "watch": "yarn prebuild && rimraf dist && concurrently 'npm:watch-*(!firefox)'",
+    "watch:firefox": "yarn prebuild && concurrently 'npm:watch-*(!chrome)'",
     "watch-contentscript": "rollup --watch --config configs/rollup.config.contentscript.mjs",
     "watch-inject": "rollup --watch --config configs/rollup.config.inject.mjs",
     "watch-vue-chrome": "cross-env BROWSER='chrome' vue-cli-service build --watch --no-clean",
@@ -74,6 +76,7 @@
   },
   "devDependencies": {
     "@babel/plugin-transform-class-static-block": "^7.23.4",
+    "@kadena/pactjs-cli": "^1.7.0",
     "@polkadot/api": "^10.11.2",
     "@polkadot/extension-inject": "^0.46.6",
     "@polkadot/keyring": "^12.6.2",

packages/extension/src/libs/domain-state/index.ts

@@ -21,6 +21,16 @@ class DomainState {
     if (state.selectedNetwork) return state.selectedNetwork;
     return null;
   }
+  async setSelectedSubNetwork(id: string): Promise<void> {
+    const state = await this.getState();
+    state.selectedSubNetworkId = id;
+    await this.setState(state);
+  }
+  async getSelectedSubNetWork(): Promise<string | null> {
+    const state = await this.getState();
+    if (state.selectedSubNetworkId) return state.selectedSubNetworkId;
+    return null;
+  }
   async setSelectedAddress(address: string): Promise<void> {
     const state = await this.getState();
     state.selectedAddress = address;

packages/extension/src/libs/domain-state/types.ts

@@ -3,5 +3,6 @@ export enum StorageKeys {
 }
 export interface IState {
   selectedNetwork?: string;
+  selectedSubNetworkId?: string;
   selectedAddress?: string;
 }

packages/extension/src/providers/kadena/libs/accounts-state/index.ts

@@ -1,6 +1,7 @@
 import { InternalStorageNamespace } from "@/types/provider";
 import BrowserStorage from "@/libs/common/browser-storage";
 import { IState, StorageKeys } from "./types";
+
 class AccountState {
   #storage: BrowserStorage;
   constructor() {

packages/extension/src/providers/kadena/libs/activity-handlers/providers/kadena/index.ts

@@ -13,7 +13,6 @@ const getAddressActivity = async (
   height: number
 ): Promise<any[]> => {
   const url = `${endpoint}txs/account/${address}?minheight=${height}&limit=200&token=coin`;
-
   return cacheFetch({ url }, ttl)
     .then((res) => {
       return res ? res : [];
@@ -72,13 +71,25 @@ export default async (
         : "0",
       network.decimals
     );
+    // note: intentionally not using fromAccount === some-value
+    // I want to match both null and "" in fromAccount/toAccount
+    // actual values will be a (truthy) string
+    let { fromAccount, toAccount } = activity;
+    if (!fromAccount && activity.crossChainAccount) {
+      fromAccount = activity.crossChainAccount;
+    }
+    if (!toAccount && activity.crossChainAccount) {
+      toAccount = activity.crossChainAccount;
+    }
     return {
       nonce: i.toString(),
-      from: activity.fromAccount,
-      to: activity.toAccount,
+      from: fromAccount,
+      to: toAccount,
       isIncoming: activity.fromAccount !== address,
       network: network.name,
       rawInfo: activity,
+      chainId: activity.chain.toString(),
+      crossChainId: activity.crossChainId,
       status:
         activity.idx === 1 ? ActivityStatus.success : ActivityStatus.failed,
       timestamp: new Date(activity.blockTime).getTime(),

packages/extension/src/providers/kadena/libs/api.ts

@@ -3,18 +3,23 @@ import { ProviderAPIInterface } from "@/types/provider";
 import { KadenaNetworkOptions } from "../types/kadena-network";
 import {
   ICommand,
+  IUnsignedCommand,
   ICommandResult,
   ITransactionDescriptor,
   createClient,
+  Pact,
+  ChainId,
 } from "@kadena/client";
 import { toBase } from "@enkryptcom/utils";
+import DomainState from "@/libs/domain-state";
 
 class API implements ProviderAPIInterface {
   decimals: number;
   node: string;
   networkId: string;
   chainId: string;
   apiHost: string;
+  domainState: DomainState;
   displayAddress: (address: string) => string;
 
   constructor(node: string, options: KadenaNetworkOptions) {
@@ -24,29 +29,53 @@ class API implements ProviderAPIInterface {
     this.chainId = options.kadenaApiOptions.chainId;
     this.apiHost = `${node}/${this.networkId}/chain/${this.chainId}/pact`;
     this.displayAddress = options.displayAddress;
+    this.domainState = new DomainState();
   }
 
   public get api() {
     return this;
   }
 
+  private getApiHost(chainId: string) {
+    return `${this.node}/${this.networkId}/chain/${chainId}/pact`;
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   async init(): Promise<void> {}
 
-  async getTransactionStatus(hash: string): Promise<KadenaRawInfo | null> {
-    const Pact = require("pact-lang-api");
-
-    const cmd = { requestKeys: [hash] };
-    const transactions = await Pact.fetch.poll(cmd, this.apiHost);
+  async getChainId(): Promise<string> {
+    return this.domainState.getSelectedSubNetWork().then((id) => {
+      if (id) return id;
+      return "0";
+    });
+  }
 
-    return transactions[hash];
+  async getTransactionStatus(requestKey: string): Promise<KadenaRawInfo> {
+    const chainId = await this.getChainId();
+    const networkId = this.networkId;
+    const { pollStatus } = createClient(this.getApiHost(chainId));
+    const responses = await pollStatus({
+      requestKey,
+      networkId,
+      chainId: chainId as ChainId,
+    });
+    return responses[requestKey];
   }
 
-  async getBalance(address: string): Promise<string> {
-    const balance = await this.getBalanceAPI(this.displayAddress(address));
+  async getBalanceByChainId(address: string, chainId: string): Promise<string> {
+    const balance = await this.getBalanceAPI(
+      this.displayAddress(address),
+      chainId
+    );
 
-    if (balance.result.error) {
-      return toBase("0", this.decimals);
+    if (balance.result.status === "failure") {
+      const error = balance.result.error as { message: string | undefined };
+      const message = error.message ?? "Unknown error retrieving balances";
+      // expected error when account does not exist on a chain (balance == 0)
+      if (message.includes("row not found")) {
+        return toBase("0", this.decimals);
+      }
+      throw new Error(message);
     }
 
     const balanceValue = parseFloat(balance.result.data.toString()).toFixed(
@@ -56,49 +85,50 @@ class API implements ProviderAPIInterface {
     return toBase(balanceValue, this.decimals);
   }
 
-  async getBalanceAPI(account: string) {
-    const Pact = require("pact-lang-api");
-
-    const cmd = {
-      networkId: this.networkId,
-      pactCode: `(coin.get-balance "${account}")`,
-      envData: {},
-      meta: {
-        creationTime: Math.round(new Date().getTime() / 1000),
-        ttl: 600,
-        gasLimit: 600,
-        chainId: this.chainId,
-        gasPrice: 0.0000001,
-        sender: "",
-      },
-    };
-
-    return Pact.fetch.local(cmd, this.apiHost);
+  async getBalance(address: string): Promise<string> {
+    const chainId = await this.getChainId();
+    return this.getBalanceByChainId(address, chainId);
+  }
+
+  async getBalanceAPI(account: string, chainId: string) {
+    const transaction = Pact.builder
+      .execution(Pact.modules.coin["get-balance"](account))
+      .setMeta({ chainId: chainId as ChainId })
+      .setNetworkId(this.networkId)
+      .createTransaction();
+
+    return this.dirtyRead(transaction);
   }
 
   async sendLocalTransaction(
     signedTranscation: ICommand
   ): Promise<ICommandResult> {
-    const client = createClient(this.apiHost);
+    const chainId = await this.getChainId();
+    const client = createClient(this.getApiHost(chainId));
     return client.local(signedTranscation as ICommand);
   }
 
   async sendTransaction(
     signedTranscation: ICommand
   ): Promise<ITransactionDescriptor> {
-    const client = createClient(this.apiHost);
+    const chainId = await this.getChainId();
+    const client = createClient(this.getApiHost(chainId));
     return client.submit(signedTranscation as ICommand);
   }
 
   async listen(
     transactionDescriptor: ITransactionDescriptor
   ): Promise<ICommandResult> {
-    const client = createClient(this.apiHost);
+    const chainId = await this.getChainId();
+    const client = createClient(this.getApiHost(chainId));
     return client.listen(transactionDescriptor);
   }
 
-  async dirtyRead(signedTranscation: ICommand): Promise<ICommandResult> {
-    const client = createClient(this.apiHost);
+  async dirtyRead(
+    signedTranscation: ICommand | IUnsignedCommand
+  ): Promise<ICommandResult> {
+    const chainId = await this.getChainId();
+    const client = createClient(this.getApiHost(chainId));
     return client.dirtyRead(signedTranscation);
   }
 }

packages/extension/src/providers/kadena/methods/kda_getBalance.ts

@@ -2,6 +2,7 @@ import { MiddlewareFunction } from "@enkryptcom/types";
 import KadenaProvider from "..";
 import { ProviderRPCRequest } from "@/types/provider";
 import { getCustomError } from "@/libs/error";
+import type KadenaAPI from "@/providers/kadena/libs/api";
 
 const method: MiddlewareFunction = function (
   this: KadenaProvider,
@@ -11,12 +12,15 @@ const method: MiddlewareFunction = function (
 ): void {
   if (payload.method !== "kda_getBalance") return next();
   else {
-    if (!payload.params || payload.params.length < 1) {
+    if (!payload.params || payload.params.length < 2) {
       return res(getCustomError("kda_getBalance: invalid params"));
     }
 
+    const address = payload.params[0];
+    const chainId =
+      payload.params[1] ?? this.network.options.kadenaApiOptions.chainId;
     this.network.api().then((api) => {
-      api.getBalance(payload.params![0]).then((bal) => {
+      (api as KadenaAPI).getBalanceByChainId(address, chainId).then((bal) => {
         res(null, bal);
       });
     });

packages/extension/src/providers/kadena/methods/kda_requestAccounts.ts

@@ -97,28 +97,46 @@ const method: MiddlewareFunction = function (
         isAccountAccessPending = true;
         const accountsState = new AccountState();
 
-        accountsState.isApproved(_payload.options.domain).then((isApproved) => {
-          if (isApproved) {
-            getAccounts().then((acc) => {
-              _res(null, acc);
-              handleRemainingPromises();
-            });
-          } else {
-            const windowPromise = new WindowPromise();
-            windowPromise
-              .getResponse(
-                this.getUIPath(this.UIRoutes.kdaAccounts.path),
-                JSON.stringify(payload)
-              )
-              .then(({ error }) => {
-                if (error) res(error);
-                else getAccounts().then((acc) => res(null, acc));
-              })
-              .finally(handleRemainingPromises);
-          }
-        });
+        accountsState
+          .isApproved(_payload.options.domain)
+          .then((isApproved) => {
+            if (isApproved) {
+              getAccounts()
+                .then((acc) => {
+                  _res(null, acc);
+                })
+                .catch((err) => {
+                  throw err;
+                });
+            } else {
+              const windowPromise = new WindowPromise();
+              windowPromise
+                .getResponse(
+                  this.getUIPath(this.UIRoutes.kdaAccounts.path),
+                  JSON.stringify(payload)
+                )
+                .then(({ error }) => {
+                  if (error) {
+                    throw error;
+                  } else {
+                    getAccounts()
+                      .then((acc) => {
+                        _res(null, acc);
+                      })
+                      .catch((err) => {
+                        throw err;
+                      });
+                  }
+                });
+            }
+          })
+          .catch((err) => {
+            _res(err);
+          })
+          .finally(handleRemainingPromises);
       } else {
         _res(getCustomError("No domain set!"));
+        handleRemainingPromises();
       }
     };
 

packages/extension/src/providers/kadena/networks/kadena-testnet.ts

@@ -22,6 +22,15 @@ const kadenaOptions: KadenaNetworkOptions = {
     networkId: "testnet04",
     chainId: "1",
   },
+  subNetworks: Array(20)
+    .fill("")
+    .map((_, idx) => {
+      return {
+        id: idx.toString(),
+        name: `Chain ${idx}`,
+      };
+    }),
+  buyLink: "https://tools.kadena.io/faucet/new",
   activityHandler: wrapActivityHandler(kadenaScanActivity),
   displayAddress: (address: string) => address.replace("0x", "k:"),
   isAddress: isValidAddress,