ps-filter 0.0.1

package/Procfile

@@ -0,0 +1 @@
+web: node ./src/api.js

package/README.md

@@ -0,0 +1,22 @@
+<p align="center">
+  <a href="https://decent.land">
+    <img src="./img/logo25.png" height="124">
+  </a>
+  <h3 align="center"><code>@decentdotland/ps-filter</code></h3>
+  <p align="center">cache node & FE filter for the PublicSquare protocol</p>
+</p>
+
+## Synopsis
+A cache node for the [filter layer](./contracts) (SmartWeave contract) of the PublicSquare protocol.
+
+## API Endpoints
+
+### 1- decoded cached feed 
+- Request: GET `/feeds`
+- Response: Array of posts objects
+
+## Further Documentation
+TODO
+
+## License
+This project is licensed under the [MIT license](./LICENSE).

package/contracts/filter.js

@@ -0,0 +1,525 @@
+export async function handle(state, action) {
+  const input = action.input;
+  const caller = action.caller;
+
+  const rate_limit = state.rate_limit;
+  const post_char_limit = state.post_char_limit;
+  const representatives = state.representatives;
+  const super_representatives = state.super_representatives;
+
+  const ERROR_INVALID_NFT_SRC = "post's NFT SRC is not supported";
+  const  ERROR_PID_ALREADY_EXIST = "PID already exits";
+  const ERROR_PID_NOT_EXIST = "the given PID not found";
+  const ERROR_INVALID_REPLY_TYPE = "reply's type must be of type 'post'";
+  const ERROR_USER_ADDRESS_NOT_EXIST =
+    "the given address has not interacted with the contract";
+  const ERROR_USER_ALREADY_SUSPENDED =
+    "user already suspended - duplicated action";
+  const ERROR_USER_NEVER_REPORTED =
+    "cannot suspend a user without at least a single report by a representative";
+  const ERROR_INVALID_CHAR_LIMIT =
+    "characters limit must be an integer greater than the min-safe limit";
+  const ERROR_INVALID_RATE_LIMIT =
+    "rate limit must be an integer less than the max-safe limit";
+  const ERROR_INVALID_INPUT = "the function has been given an invalid argument";
+  const ERROR_INVALID_PRIMITIVE_TYPE = "invalid primitive data type";
+  const ERROR_INVALID_STRING_LENGTH =
+    "the string surpass the allowed min-max limits";
+  const ERROR_CONTENT_BODY_IS_NOT_JSON =
+    "post content body is not a valid JSON";
+  const ERROR_INVALID_ARWEAVE_ADDRESS_TRANSACTION =
+    "the syntax of the string is not a valid Arweave address/TX";
+  const ERROR_POST_OWNER_NOT_CALLER = "the PID owner is not the caller";
+  const ERROR_INVALID_TX_TAG = "the TX has invalid TX tag(s)";
+  const ERROR_INVALID_POST_STRUCTURE = "PID data structure is not valid";
+  const ERROR_RATE_LIMIT = "user cannot post, has reached the rate limit";
+  const ERROR_USER_SUSPENDED = "user cannot post, has been suspended";
+  const ERROR_CALLER_NOT_REPRESENTATIVE =
+    "only a representative address can invoke this function";
+  const ERROR_REPORT_NOT_EXIST_OR_EXECUTED =
+    "report ID does not exist or the report has been executed";
+  const ERROR_CONTRACT_TEMPORARY_SEALED =
+    "the filter contract is sealed temporary - users interactions are revoked automatically";
+
+  if (input.function === "post") {
+    const txid = input.txid;
+
+    _checkSealing(state.is_sealed, caller);
+    _validateArweaveAddress(txid);
+    _checkPostDuplication(txid);
+    // get TX tags & validate post ownership
+    const tx_tags = await _getTransactionTags(txid, caller);
+
+    const post_src = state.nfts_src[0];
+    // const poll_src = state.nfts_src[1];
+    let post_type; // post or poll
+
+    _checkTagExistence(tx_tags, "App-Name", "SmartWeaveContract");
+    _checkTagExistence(tx_tags, "App-Version", "0.3.0");
+    _checkTagExistence(tx_tags, "Content-Type", "application/json");
+    _checkTagExistence(tx_tags, "Protocol-Name", "DecentLand");
+    _checkTagExistence(tx_tags, "Protocol-Action", "post");
+    _checkTagExistence(tx_tags, "Tribus-ID", SmartWeave.contract.id);
+
+    if (
+      !tx_tags["Contract-Src"] ||
+      !state.nfts_src.includes(tx_tags["Contract-Src"])
+    ) {
+      throw new ContractError(ERROR_INVALID_NFT_SRC);
+    }
+
+    await _checkPostStructure(txid);
+
+    // if (tx_tags["Contract-Src"] === poll_src) {
+    //   await _checkPollStructure(txid);
+    //   post_type = "poll"
+    // }
+
+    if (!(caller in state.users)) {
+      state.users[caller] = {
+        last_interaction: 0,
+        reports_count: 0,
+        user_status: "OK",
+      };
+    }
+
+    _checkUserStatus(caller);
+    _checkUserRateLimit(caller);
+
+    state.users[caller].last_interaction = SmartWeave.block.height;
+
+    state.feed.push({
+      pid: txid,
+      type: "post", // hardcoded
+      owner: caller,
+      timestamp: SmartWeave.block.timestamp,
+      replies: [],
+    });
+
+    return { state };
+  }
+
+  if (input.function === "reply") {
+    const txid = input.txid;
+    const post_id = input.post_id;
+
+    _checkSealing(state.is_sealed, caller);
+    _validateArweaveAddress(txid);
+    _checkPostDuplication(txid);
+
+    const post_id_index = state.feed.findIndex((post) => post.pid === post_id);
+    const post_type = _getPostType(post_id);
+
+    if (post_id_index === -1) {
+      throw new ContractError(ERROR_PID_NOT_EXIST);
+    }
+
+    // get TX tags & validate post ownership
+    const tx_tags = await _getTransactionTags(txid, caller);
+
+    const post_src = state.nfts_src[0];
+
+    _checkTagExistence(tx_tags, "App-Name", "SmartWeaveContract");
+    _checkTagExistence(tx_tags, "App-Version", "0.3.0");
+    _checkTagExistence(tx_tags, "Content-Type", "application/json");
+    _checkTagExistence(tx_tags, "Protocol-Name", "DecentLand");
+    _checkTagExistence(tx_tags, "Protocol-Action", "reply");
+    _checkTagExistence(tx_tags, "reply_to", post_id);
+    _checkTagExistence(tx_tags, "Tribus-ID", SmartWeave.contract.id);
+
+    if (
+      !tx_tags["Contract-Src"] ||
+      !state.nfts_src.includes(tx_tags["Contract-Src"])
+    ) {
+      throw new ContractError(ERROR_INVALID_NFT_SRC);
+    }
+
+    // reply can be type of 'post' only
+    if (tx_tags["Contract-Src"] !== post_src) {
+      throw new ContractError(ERROR_INVALID_REPLY_TYPE);
+    }
+
+    await _checkPostStructure(txid);
+
+    if (!(caller in state.users)) {
+      state.users[caller] = {
+        last_interaction: 0,
+        reports_count: 0,
+        user_status: "OK",
+      };
+    }
+
+    _checkUserStatus(caller);
+    _checkUserRateLimit(caller);
+
+    state.users[caller].last_interaction = SmartWeave.block.height;
+
+    state.feed[post_id_index]["replies"].push({
+      pid: txid,
+      childOf: post_id,
+      owner: caller,
+      timestamp: SmartWeave.block.timestamp,
+    });
+
+    return { state };
+  }
+
+  // REPRESENTATIVES ACTIONS
+  if (input.function === "report_post") {
+    const pid = input.pid;
+    const message = input.message;
+
+    _isRepresentative(caller);
+
+    const is_post = state.feed.find((post) => post["pid"] === pid);
+
+    if (!is_post) {
+      throw new ContractError(ERROR_PID_NOT_EXIST);
+    }
+
+    const report_index = state.reports.findIndex(
+      (report) =>
+        report.type === "post_report" &&
+        report["pid"] === pid &&
+        !report?.reporters?.includes(caller)
+    );
+
+    if (report_index !== -1) {
+      const report = state.reports[report_index];
+      report.reporters.push(caller);
+      reports_count += 1;
+
+      return { state };
+    }
+
+    state.reports.push({
+      report_id: SmartWeave.transaction.id,
+      pid: pid,
+      type: "post_report",
+      message: message,
+      reporters: [caller],
+      reports_count: 0,
+    });
+
+    return { state };
+  }
+  // SUPER REPRESENTATIVE ACTIONS
+  if (input.function === "execute_report") {
+    const report_id = input.report_id;
+
+    _isSuperRepresentative(caller);
+
+    const report_index = _getReportIndex(report_id);
+    const report = state.reports[report_index];
+
+    if (report["type"] === "post_report") {
+      const pid = report["pid"];
+      const post_index = state.feed.findIndex((post) => post["pid"] === pid);
+      const post_owner = state.feed[post_index]["owner"];
+
+      state.feed.splice(post_index, 1);
+      state.reports[report_index].status = "executed";
+      state.users[post_owner]["reports_count"] += 1;
+
+      return { state };
+    }
+
+    if (report["type"] === "reply_report") {
+      const pid = report["pid"];
+      const post_index = state.feed.findIndex((post) =>
+        post["replies"].find((reply) => reply["pid"] === pid)
+      );
+      const reply_index = state.feed[post_index]["replies"].find(
+        (reply) => reply["pid"] === pid
+      );
+      const post_owner =
+        state.feed[post_index]["replies"][reply_index]["owner"];
+
+      state.feed[post_index]["replies"].splice(reply_index, 1);
+      state.reports[report_index].status = "executed";
+      state.users[post_owner]["reports_count"] += 1;
+
+      return { state };
+    }
+
+    return { state };
+  }
+
+  if (input.function === "suspend_user") {
+    const user_address = input.user_address;
+
+    _validateArweaveAddress(user_address);
+    _isSuperRepresentative(caller);
+
+    if (!state.users.user_address) {
+      throw new ContractError(ERROR_USER_ADDRESS_NOT_EXIST);
+    }
+
+    if (state.users.user_address.user_status !== "OK") {
+      throw new ContractError(ERROR_USER_ALREADY_SUSPENDED);
+    }
+
+    const user_reports_count = state.users.user_address.reports_count;
+    const user_super_reports =
+      state.users.user_address?.super_rep_reports_count;
+    const super_rep_half_plus_one =
+      Math.trunc(state.super_representatives.length / 2) + 1;
+
+    // user must be reported by atleast a single representative
+    if (user_reports_count === 0) {
+      throw new ContractError(ERROR_USER_NEVER_REPORTED);
+    }
+
+    if (!user_super_reports) {
+      state.users.user_address.super_rep_reports_count = 1;
+      // executed if sup_rep count = 1
+      if (user_super_reports >= super_rep_half_plus_one) {
+        state.users.user_address.user_status = "SUSPENDED";
+        return { state };
+      }
+      return { state };
+    }
+
+    if (user_super_reports < super_rep_half_plus_one) {
+      state.users.user_address.super_rep_reports_count += 1;
+
+      if (user_super_reports >= super_rep_half_plus_one) {
+        state.users.user_address.user_status = "SUSPENDED";
+        return { state };
+      }
+
+      return { state };
+    }
+    state.users.user_address.super_rep_reports_count += 1;
+    state.users.user_address.user_status = "SUSPENDED";
+
+    return { state };
+  }
+
+  if (input.function === "edit_characters_limit") {
+    const new_char_limit = input.new_char_limit;
+    const safe_minimum_limit = 280;
+
+    _isSuperRepresentative(caller);
+
+    if (
+      !Number.isInteger(new_char_limit) ||
+      new_char_limit < safe_minimum_limit
+    ) {
+      throw new ContractError(ERROR_INVALID_CHAR_LIMIT);
+    }
+
+    state.post_char_limit = new_limit;
+
+    return { state };
+  }
+
+  if (input.function === "edit_rate_limit") {
+    const new_rate_limit = input.new_rate_limit;
+    // 30 blocks delay between every interaction;
+    const safe_maximum_limit = 30;
+
+    _isSuperRepresentative(caller);
+
+    if (!Number.isInteger(new_rate_limit) || new_limit > safe_maximum_limit) {
+      throw new ContractError(ERROR_INVALID_RATE_LIMIT);
+    }
+
+    state.rate_limit = new_rate_limit;
+
+    return { state };
+  }
+
+  if (input.function === "edit_sealing") {
+    const sealing = input.sealing;
+
+    _isSuperRepresentative(caller);
+
+    if (![true, false].includes(sealing)) {
+      throw new ContractError(ERROR_INVALID_INPUT);
+    }
+
+    state.is_sealed = sealing;
+
+    return { state };
+  }
+
+  if (input.function === "remove_representative") {
+    const address = input.address;
+
+    _isSuperRepresentative(caller);
+    _isRepresentative(address);
+
+    const representativeIndex = state.representatives.findIndex(address);
+    state.representatives.splice(representativeIndex, 1);
+
+    return { state };
+  }
+
+  // HELPER FUNCTIONS
+  function _validateStringTypeLen(str, minLen, maxLen) {
+    if (typeof str !== "string") {
+      throw new ContractError(ERROR_INVALID_PRIMITIVE_TYPE);
+    }
+
+    if (str.length < minLen || str.length > maxLen) {
+      throw new ContractError(ERROR_INVALID_STRING_LENGTH);
+    }
+  }
+
+  function _validateArweaveAddress(str) {
+    _validateStringTypeLen(str, 43, 43);
+
+    const validity = /[a-z0-9_-]{43}/i.test(str);
+    if (!validity) {
+      throw new ContractError(ERROR_INVALID_ARWEAVE_ADDRESS_TRANSACTION);
+    }
+  }
+
+  async function _getTransactionTags(txid, address) {
+    const tags = {};
+    const tx_object = await SmartWeave.unsafeClient.transactions.get(txid);
+    const tx_owner_decoded =
+      await SmartWeave.unsafeClient.wallets.ownerToAddress(tx_object.owner);
+    const tx_tags = tx_object.get("tags");
+
+    for (let tag of tx_tags) {
+      const key = tag.get("name", { decode: true, string: true });
+      const value = tag.get("value", { decode: true, string: true });
+
+      tags[key] = value;
+    }
+
+    if (tx_owner_decoded !== address) {
+      throw new ContractError(ERROR_POST_OWNER_NOT_CALLER);
+    }
+
+    return tags;
+  }
+
+  function _checkTagExistence(tags_object, key, value) {
+    if (!(key in tags_object) || tags_object[key] !== value) {
+      throw new ContractError(ERROR_INVALID_TX_TAG);
+    }
+  }
+
+  function _checkPostDuplication(txid) {
+    const post_existence = state.feed.find((post) => post.pid === txid);
+    const reply_existence = state.feed.find((post) =>
+      post["replies"].find((reply) => reply.pid === txid)
+    );
+
+    if (post_existence || reply_existence) {
+      throw new ContractError(ERROR_PID_ALREADY_EXIST);
+    }
+  }
+
+  function _get_data_type(data) {
+    return Object.prototype.toString.call(data);
+  }
+
+  async function _checkPostStructure(txid) {
+    const content_string = await SmartWeave.unsafeClient.transactions.getData(
+      txid,
+      { decode: true, string: true }
+    );
+
+    try {
+      JSON.parse(content_string);
+    } catch (error) {
+      throw new ContractError(ERROR_CONTENT_BODY_IS_NOT_JSON);
+    }
+
+    const content_object = JSON.parse(content_string);
+
+    const isObject = _get_data_type(content_object) === "[object Object]";
+    const hasContent =
+      content_object.content &&
+      _get_data_type(content_object.content) === "[object String]";
+    const hasMediaArray =
+      content_object.media &&
+      _get_data_type(content_object.media) === "[object Array]";
+    const hasOnlyContentAndMedia = Object.keys(content_object).length === 2;
+    const isEmptyPost =
+      content_object?.content?.length + content_object?.media?.length === 0;
+    const isContentBelowLimit =
+      content_object.content?.length < post_char_limit;
+
+    if (
+      isObject &&
+      hasContent &&
+      hasMediaArray &&
+      hasOnlyContentAndMedia &&
+      isContentBelowLimit &&
+      !isEmptyPost
+    ) {
+      return true;
+    }
+
+    throw new ContractError(ERROR_INVALID_POST_STRUCTURE);
+  }
+
+  function _checkUserRateLimit(address) {
+    const current_blockheight = SmartWeave.block.height;
+    const current_user_blockheight = state.users[address].last_interaction;
+    const get_rate_limit = state.users[address]["rate_limit"]
+      ? state.users[address]["rate_limit"]
+      : state.rate_limit;
+
+    if (!(current_user_blockheight < current_blockheight + get_rate_limit)) {
+      throw new ContractError(ERROR_RATE_LIMIT);
+    }
+  }
+
+  function _checkUserStatus(address) {
+    const status = state.users[address].user_status;
+
+    if (status !== "OK") {
+      throw new ContractError(ERROR_USER_SUSPENDED);
+    }
+  }
+
+  function _isRepresentative(address) {
+    const is_rep = representatives.includes(address);
+
+    if (!is_rep) {
+      throw new ContractError(ERROR_CALLER_NOT_REPRESENTATIVE);
+    }
+  }
+
+  function _isSuperRepresentative(address) {
+    const is_rep = super_representatives.includes(address);
+
+    if (!is_rep) {
+      throw new ContractError(ERROR_CALLER_NOT_REPRESENTATIVE);
+    }
+  }
+
+  function _getReportIndex(id) {
+    // report.status is defined when the report get executed
+    // not executed report have no status
+    const index = state.reports.findIndex(
+      (report) => report["report_id"] === id && report.status
+    );
+
+    if (index === -1) {
+      throw new ContractError(ERROR_REPORT_NOT_EXIST_OR_EXECUTED);
+    }
+  }
+
+  function _getPostType(post_id) {
+    const post_index = state.feed.findIndex((post) => post.pid === post_id);
+    if (post_index === -1) {
+      throw new ContractError(ERROR_PID_NOT_EXIST);
+    }
+
+    return state.feed[post_index].type;
+  }
+
+  function _checkSealing(filter_sealing_state, address) {
+    if (filter_sealing_state && !(address in state.users)) {
+      throw new ContractError(ERROR_CONTRACT_TEMPORARY_SEALED);
+    }
+  }
+}
+

package/contracts/filter.json

@@ -0,0 +1,10 @@
+{	"nfts_src": ["I8xgq3361qpR8_DvqcGpkCYAUTMktyAgvkm6kGhJzEQ"],
+	"rate_limit": 0,
+	"post_char_limit": 750,
+	"is_sealed": false,
+	"feed": [],
+	"users": {},
+	"representatives": ["vZY2XY1RD9HIfWi8ift-1_DnHLDadZMWrufSh-_rKF0"],
+	"super_representatives": ["vZY2XY1RD9HIfWi8ift-1_DnHLDadZMWrufSh-_rKF0"],
+	"reports": []
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "ps-filter",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "a cache node for the filter-layer of the PublicSquare protocol",
+  "main": "./src/api.js",
+  "scripts": {
+    "start": "node ./src/api.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/decentldotland/ps-filter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/decentldotland/ps-filter/issues"
+  },
+  "keywords": [
+    "public-square",
+    "web3",
+    "arweave",
+    "social"
+  ],
+  "author": "charmful0x",
+  "license": "MIT",
+  "dependencies": {
+    "arweave": "^1.10.23",
+    "axios": "^0.26.0",
+    "base64url": "^3.0.1",
+    "cors": "^2.8.5",
+    "express": "^4.17.3",
+    "node-cache": "^5.1.2",
+    "redstone-smartweave": "^0.4.71"
+  }
+}

package/src/api.js

@@ -0,0 +1,37 @@
+import express from "express";
+import base64url from "base64url";
+import cors from "cors";
+import { getFeed, cache } from "./utils/cache.js";
+import { timeout } from "./utils/arweave.js";
+
+const app = express();
+const port = process.env.PORT || 7777;
+
+app.use(
+  cors({
+    origin: "*",
+  })
+);
+
+app.get("/feeds", async (req, res) => {
+  res.setHeader("Content-Type", "application/json");
+  const encodedFeed = await getFeed();
+  const jsonRes = JSON.parse(base64url.decode(encodedFeed));
+  res.send(jsonRes);
+});
+
+app.listen(port, async () => {
+  await polling();
+  console.log(`listening at PORT:${port}`);
+});
+
+async function polling() {
+  while (true) {
+    try {
+      await cache();
+      await timeout();
+    } catch (error) {
+      console.log(error);
+    }
+  }
+}

package/src/utils/arweave.js

@@ -0,0 +1,34 @@
+import Arweave from "arweave";
+import { SmartWeaveNodeFactory } from "redstone-smartweave";
+import { FILTER_SWC_ADDRESS, BLOCK_SLEEPING_TIMEOUT } from "./constants.js";
+
+export const arweave = Arweave.init({
+  host: "arweave.net",
+  port: 443,
+  protocol: "https",
+  timeout: 20000,
+  logging: false,
+});
+
+const smartweave = SmartWeaveNodeFactory.memCached(arweave);
+
+export async function readFilterContract() {
+  try {
+    const contract = smartweave.contract(FILTER_SWC_ADDRESS);
+    const { state, validity } = await contract.readState();
+
+    return state;
+  } catch (error) {
+    console.log(error);
+    return false;
+  }
+}
+
+export function timeout() {
+  // a block is ~ 2 min
+  const ms = BLOCK_SLEEPING_TIMEOUT * 2 * 60 * 1e3;
+  console.log(
+    `\nsleeping for ${BLOCK_SLEEPING_TIMEOUT} network blocks or ${ms} ms\n`
+  );
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/utils/cache.js

@@ -0,0 +1,61 @@
+import { readFilterContract, arweave } from "./arweave.js";
+import { readAndEncode } from "./filter.js";
+import { getLastInteraction } from "./getLastInteraction.js";
+import NodeCache from "node-cache";
+import base64url from "base64url";
+
+const base64Cache = new NodeCache();
+
+export async function cache() {
+  const lastInteraction = (await getLastInteraction())[0]?.block;
+  const currentBlock = (await arweave.blocks.getCurrent())?.height;
+
+  // initialization
+  if (!base64Cache.has("feed")) {
+    const feed = await readAndEncode();
+    base64Cache.set("raw", feed.raw);
+    base64Cache.set("feed", feed.loaded);
+    base64Cache.set("height", currentBlock);
+
+    console.log(`STATE ALREADY CACHED - HEIGHT: ${base64Cache.get("height")}`);
+  }
+
+  // cache new interactions
+  if (
+    !base64Cache.get("height") ||
+    base64Cache.get("height") < lastInteraction
+  ) {
+    const feed = await readAndEncode();
+    base64Cache.set("raw", feed.raw);
+    base64Cache.set("feed", feed.loaded);
+    base64Cache.set("height", lastInteraction);
+
+    console.log(`NEW STATE CACHED - HEIGHT: ${lastInteraction}`);
+  }
+}
+
+export async function getPidData(pid) {
+  try {
+    // feed is passed by readAndEncode();
+    if (base64Cache.has(pid)) {
+      return base64Cache.get(pid);
+    }
+    // if not cached, cache it
+    const contentData = await arweave.transactions.getData(pid, {
+      decode: true,
+      string: true,
+    });
+    base64Cache.set(pid, contentData);
+    return base64Cache.get(pid);
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+export async function getFeed() {
+  if (!base64Cache.has("feed")) {
+    return "e30";
+  }
+
+  return base64Cache.get("feed");
+}

package/src/utils/constants.js

@@ -0,0 +1,4 @@
+export const FILTER_SWC_ADDRESS = "k-ld4VIqoZF5XnlQLCt71wbow5vit1nATnCTMAnug5g";
+export const BLOCK_SLEEPING_TIMEOUT = 3;
+
+// not used: IfPzGFarZAaIlxpmAz5DvEYR4127K3mPI6sFoTfxwNg

package/src/utils/filter.js

@@ -0,0 +1,46 @@
+import { readFilterContract } from "./arweave.js";
+import { getPidData } from "./cache.js";
+import base64url from "base64url";
+
+export async function readAndEncode() {
+  try {
+    const feed0 = (await readFilterContract()).feed;
+    const feed1 = await getFeed1(feed0);
+    const feed2 = await getFeed2(feed1);
+  
+    return {
+      loaded: base64url(JSON.stringify(feed2)), // post's TXID (data) is decoded
+      raw: base64url(JSON.stringify(feed0)) // post content is encoded as Arweave TXID
+    }
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+async function getFeed1(feed) {
+  try {
+    for (let thread of feed) {
+      thread.pid = await getPidData(thread.pid);
+    }
+
+    return feed;
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+async function getFeed2(feed) {
+  try {
+    for (let thread of feed) {
+      if (thread.replies.length > 0) {
+        for (let reply of thread.replies) {
+          reply.pid = await getPidData(reply.pid);
+        }
+      }
+    }
+
+    return feed;
+  } catch (error) {
+    console.log(error);
+  }
+}

package/src/utils/getLastInteraction.js

@@ -0,0 +1,58 @@
+import axios from "axios";
+import { FILTER_SWC_ADDRESS } from "./constants.js";
+import { arweave } from "./arweave.js";
+
+const gqlQuery = {
+  query: `query {
+  transactions(
+    tags: [
+        { name: "App-Name", values: "SmartWeaveAction"},
+        { name: "Contract", values: "${FILTER_SWC_ADDRESS}"}
+        ]
+    first: 1
+  ) {
+    edges {
+      node {
+        id
+        owner { address }
+        block { height }
+
+      }
+    }
+  }
+}`,
+};
+
+async function gqlTemplate(query) {
+  const response = await axios.post("https://arweave.net/graphql", query, {
+    headers: { "Content-Type": "application/json" },
+  });
+
+  const transactionIds = [];
+
+  const res_arr = response.data.data.transactions.edges;
+
+  for (let element of res_arr) {
+    const tx = element["node"];
+    const txExistence = transactionIds.find((txObj) => txObj.id === tx.id);
+
+    if (!txExistence) {
+      transactionIds.push({
+        id: tx.id,
+        owner: tx.owner.address,
+        block: tx.block ? tx.block.height : void 0,
+      });
+    }
+  }
+
+  return transactionIds;
+}
+
+export async function getLastInteraction() {
+  try {
+    const re = await gqlTemplate(gqlQuery);
+    return re;
+  } catch (error) {
+    console.log(error);
+  }
+}