Feature/crosschain-transactions

packages/extension/src/libs/activity-state/wrap-activity-handler.ts

@@ -1,6 +1,8 @@
+import { ActivityStatus } from "@/types/activity";
 import ActivityState from ".";
 import { ActivityHandlerType } from "./types";
 const CACHE_TTL = 1000 * 60 * 5; // 5 mins
+import { ProviderName } from "@/types/provider";
 export default (activityHandler: ActivityHandlerType): ActivityHandlerType => {
   const returnFunction: ActivityHandlerType = async (network, address) => {
     const activityState = new ActivityState();
@@ -12,19 +14,36 @@ export default (activityHandler: ActivityHandlerType): ActivityHandlerType => {
       activityState.getAllActivities(options),
       activityState.getCacheTime(options),
     ]);
-    if (cacheTime + CACHE_TTL < new Date().getTime()) {
-      const liveActivities = await activityHandler(network, address);
-      if (!activities.length) {
-        await activityState.addActivities(liveActivities, options);
-        await activityState.setCacheTime(options);
-        return liveActivities;
-      } else {
-        await activityState.addActivities(liveActivities, options);
+    const liveActivities = await activityHandler(network, address);
+    if (network.provider === ProviderName.kadena) {
+      if (cacheTime + CACHE_TTL < new Date().getTime()) {
+        const inProcessActivities = activities.filter(
+          (a) =>
+            a.status !== ActivityStatus.success &&
+            a.status !== ActivityStatus.failed
+        );
+        await activityState.deleteAllActivities(options);
+        await activityState.addActivities(
+          liveActivities.concat(inProcessActivities),
+          options
+        );
         await activityState.setCacheTime(options);
         return activityState.getAllActivities(options);
-      }
+      } else return activities;
     } else {
-      return activities;
+      if (cacheTime + CACHE_TTL < new Date().getTime()) {
+        if (!activities.length) {
+          await activityState.addActivities(liveActivities, options);
+          await activityState.setCacheTime(options);
+          return liveActivities;
+        } else {
+          await activityState.addActivities(liveActivities, options);
+          await activityState.setCacheTime(options);
+          return activityState.getAllActivities(options);
+        }
+      } else {
+        return activities;
+      }
     }
   };
   return returnFunction;

packages/extension/src/providers/common/ui/verify-transaction/verify-transaction-account.vue

@@ -15,8 +15,14 @@
     />
 
     <div class="verify-transaction-account__name">
-      <p v-if="from">From</p>
-      <p v-else>To</p>
+      <p v-if="from">
+        From
+        <span v-if="subnetwork">{{ subnetwork }}</span>
+      </p>
+      <p v-else>
+        To
+        <span v-if="subnetwork">{{ subnetwork }}</span>
+      </p>
       <h4>{{ name ? name : address }}</h4>
       <h6 v-show="!!name">
         {{ $filters.replaceWithEllipsis(address, 6, 4) }}
@@ -60,6 +66,12 @@ defineProps({
       return {};
     },
   },
+  subnetwork: {
+    type: String,
+    default: () => {
+      return null;
+    },
+  },
 });
 </script>
 

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

@@ -4,6 +4,9 @@ import { Activity, ActivityStatus, ActivityType } from "@/types/activity";
 import { BaseNetwork } from "@/types/base-network";
 import { NetworkEndpoints, NetworkTtls } from "./configs";
 import { toBase } from "@enkryptcom/utils";
+import KadenaAPI from "@/providers/kadena/libs/api";
+import { ChainId, Pact } from "@kadena/client";
+import { KadenaNetwork } from "@/providers/kadena/types/kadena-network";
 
 const getAddressActivity = async (
   address: string,
@@ -26,10 +29,14 @@ export default async (
   network: BaseNetwork,
   address: string
 ): Promise<Activity[]> => {
+  const networkOptions = (network as KadenaNetwork).options;
   const networkName = network.name as keyof typeof NetworkEndpoints;
   const enpoint = NetworkEndpoints[networkName];
   const ttl = NetworkTtls[networkName];
-  const activities = await getAddressActivity(
+  const api = (await network.api()) as KadenaAPI;
+  const chainId = await api.getChainId();
+
+  let activities = await getAddressActivity(
     address,
     enpoint,
     ttl,
@@ -45,56 +52,124 @@ export default async (
       .then((mdata) => (price = mdata || "0"));
   }
 
-  const groupActivities = activities.reduce((acc: any, activity: any) => {
-    if (!acc[activity.requestKey]) {
-      acc[activity.requestKey] = activity;
-    }
-    if (activity.idx === 1) {
-      acc[activity.requestKey] = activity;
-    }
-    return acc;
-  }, {});
-
-  return Object.values(groupActivities).map((activity: any, i: number) => {
-    const rawAmount = toBase(
-      activity.amount
-        ? parseFloat(activity.amount).toFixed(network.decimals)
-        : "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;
+  const groupActivities = activities
+    .filter(
+      (activity) =>
+        activity.chain == chainId || activity.crossChainId == chainId
+    )
+    .reduce((acc: any, activity: any) => {
+      if (!acc[activity.requestKey]) {
+        acc[activity.requestKey] = activity;
+      }
+      if (activity.idx !== 0) {
+        acc[activity.requestKey] = activity;
+      }
+      return acc;
+    }, {});
+
+  activities = Object.values(groupActivities).map(
+    (activity: any, i: number) => {
+      const rawAmount = toBase(
+        activity.amount
+          ? parseFloat(activity.amount).toFixed(network.decimals)
+          : "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: fromAccount,
+        to: toAccount,
+        isIncoming:
+          (!activity.crossChainId && fromAccount !== address) ||
+          (activity.crossChainId && activity.crossChainId === chainId),
+        network: network.name,
+        rawInfo: activity,
+        chainId: activity.chain.toString(),
+        crossChainId: activity.crossChainId,
+        status:
+          activity.idx !== 0 ? ActivityStatus.success : ActivityStatus.failed,
+        timestamp: new Date(activity.blockTime).getTime(),
+        value: rawAmount,
+        transactionHash: activity.requestKey,
+        type: ActivityType.transaction,
+        token: {
+          decimals: network.decimals,
+          icon: network.icon,
+          name: network.currencyNameLong,
+          symbol:
+            activity.token !== "coin" ? activity.token : network.currencyName,
+          price: price,
+        },
+      };
     }
-    return {
-      nonce: i.toString(),
-      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(),
-      value: rawAmount,
-      transactionHash: activity.requestKey,
-      type: ActivityType.transaction,
-      token: {
-        decimals: network.decimals,
-        icon: network.icon,
-        name: network.currencyNameLong,
-        symbol:
-          activity.token !== "coin" ? activity.token : network.currencyName,
-        price: price,
-      },
-    };
-  });
+  );
+
+  await Promise.allSettled(
+    activities.map(async (activity: any) => {
+      if (
+        activity.status === ActivityStatus.success &&
+        activity.crossChainId !== null
+      ) {
+        const fetchSpvResponse = await fetch(
+          `${network.node}/${networkOptions.kadenaApiOptions.networkId}/chain/${activity.chainId}/pact/spv`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              requestKey: activity.transactionHash,
+              targetChainId: String(activity.crossChainId),
+            }),
+          }
+        );
+
+        const spv = await fetchSpvResponse.json();
+        activity.spv = spv;
+
+        const tx = Pact.builder
+          .continuation({
+            proof: spv,
+            data: {},
+            pactId: activity.transactionHash,
+            rollback: false,
+            step: 1,
+          })
+          .setMeta({
+            chainId: String(activity.rawInfo.crossChainId) as ChainId,
+            senderAccount: activity.from,
+          })
+          .createTransaction();
+
+        const transactionResult = await api.sendLocalTransaction(
+          tx,
+          { signatureVerification: false, preflight: false },
+          String(activity.rawInfo.crossChainId) as ChainId
+        );
+
+        if (transactionResult.result.status === "success") {
+          activity.status = ActivityStatus.needs_continuation;
+
+          const gasLimit = transactionResult.metaData?.publicMeta?.gasLimit;
+          const gasPrice = transactionResult.metaData?.publicMeta?.gasPrice;
+          const gasFee = gasLimit && gasPrice ? gasLimit * gasPrice : 0;
+
+          activity.necessaryGasFeeToContinuation = gasFee;
+        }
+      }
+    })
+  );
+  return activities;
 };

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

@@ -65,7 +65,7 @@ class API implements ProviderAPIInterface {
   async getBalanceByChainId(address: string, chainId: string): Promise<string> {
     const balance = await this.getBalanceAPI(
       this.displayAddress(address),
-      chainId
+      chainId.toString()
     );
 
     if (balance.result.status === "failure") {
@@ -97,23 +97,49 @@ class API implements ProviderAPIInterface {
       .setNetworkId(this.networkId)
       .createTransaction();
 
-    return this.dirtyRead(transaction);
+    return this.dirtyRead(transaction, chainId);
   }
 
   async sendLocalTransaction(
-    signedTranscation: ICommand
+    signedTransaction: ICommand | IUnsignedCommand,
+    options?: { signatureVerification: boolean; preflight: boolean },
+    _chainId?: string
   ): Promise<ICommandResult> {
-    const chainId = await this.getChainId();
-    const client = createClient(this.getApiHost(chainId));
-    return client.local(signedTranscation as ICommand);
+    const chainId = _chainId === undefined ? await this.getChainId() : _chainId;
+    const client = createClient(
+      this.getApiHost(chainId ?? (await this.getChainId()))
+    );
+    return client.local(signedTransaction, options);
   }
 
   async sendTransaction(
-    signedTranscation: ICommand
-  ): Promise<ITransactionDescriptor> {
+    transaction: ICommand | IUnsignedCommand,
+    chainId?: string,
+    listen = false
+  ): Promise<{
+    transactionDescriptor: ITransactionDescriptor;
+    commandResult: ICommandResult | undefined;
+  }> {
+    const clientChainId = chainId || (await this.getChainId());
+    const client = createClient(this.getApiHost(clientChainId));
+    const transactionDescriptor = await client.submit(transaction as ICommand);
+    const commandResult = listen
+      ? await client.listen(transactionDescriptor)
+      : undefined;
+
+    return { transactionDescriptor, commandResult };
+  }
+
+  async pollCreateSpv(
+    transactionDescriptor: ITransactionDescriptor,
+    targetChainId: string
+  ): Promise<string> {
     const chainId = await this.getChainId();
     const client = createClient(this.getApiHost(chainId));
-    return client.submit(signedTranscation as ICommand);
+    return client.pollCreateSpv(
+      transactionDescriptor,
+      targetChainId as ChainId
+    );
   }
 
   async listen(
@@ -125,10 +151,11 @@ class API implements ProviderAPIInterface {
   }
 
   async dirtyRead(
-    signedTranscation: ICommand | IUnsignedCommand
+    signedTranscation: ICommand | IUnsignedCommand,
+    chainId?: string
   ): Promise<ICommandResult> {
-    const chainId = await this.getChainId();
-    const client = createClient(this.getApiHost(chainId));
+    const clientChainId = chainId || (await this.getChainId());
+    const client = createClient(this.getApiHost(clientChainId));
     return client.dirtyRead(signedTranscation);
   }
 }

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

@@ -80,6 +80,7 @@ const method: MiddlewareFunction = function (
             return {
               address: this.network.displayAddress(acc.address),
               publicKey: acc.publicKey.replace("0x", ""),
+              isHardware: acc.isHardware,
               genesisHash: "",
               name: acc.name,
               type: acc.signerType,