@pipedream/overledger 0.0.1 → 0.2.0

package/README.md

@@ -0,0 +1,11 @@
+# Overview
+
+The Overledger API by Quant Network allows developers to interact with multiple blockchain networks. It facilitates the creation, reading, and execution of smart contracts and transactions across different blockchains. This API simplifies the complex nature of blockchain interoperability, enabling multi-chain applications (MApps) through a single gateway.
+
+# Example Use Cases
+
+- **Automated Multi-chain Financial Reporting**: Build a workflow on Pipedream that triggers monthly, pulling transaction data from various blockchains via the Overledger API. Integrate this data with Google Sheets or a similar app on Pipedream to generate consolidated financial reports.
+
+- **Cross-Blockchain Event Monitoring**: Set up a Pipedream workflow to monitor specific events (like transactions or smart contract interactions) across multiple blockchains using Overledger. This can trigger notifications via Slack or email when predefined conditions are met, such as unusual transaction volumes or large transfers.
+
+- **Decentralized Application (DApp) Management**: Develop a workflow in Pipedream that utilizes Overledger to deploy and manage smart contracts across different blockchains. The workflow could, for instance, automatically update or verify contracts on Ethereum and Binance Smart Chain when a GitHub repository is updated, using a combination of Overledger and GitHub triggers on Pipedream.

package/actions/execute-signed-transaction/execute-signed-transaction.mjs

@@ -0,0 +1,45 @@
+import overledger from "../../overledger.app.mjs";
+
+export default {
+  key: "overledger-execute-signed-transaction",
+  name: "Execute Signed Transaction",
+  description: "Executes a signed transaction by sending it to a blockchain node via Overledger. [See the documentation](https://developers.quant.network/reference/executesignedrequest)",
+  version: "0.0.2",
+  type: "action",
+  props: {
+    overledger,
+    environment: {
+      propDefinition: [
+        overledger,
+        "environment",
+      ],
+    },
+    requestId: {
+      type: "string",
+      label: "Request ID",
+      description: "The Overledger identifier assigned to the related transaction preparation request. This should be set to the requestId parameter found in the response object of the 'Prepare a Smart Contract Transaction' Overledger action.",
+    },
+    signedTransaction: {
+      type: "string",
+      label: "Signed Transaction",
+      description: "The raw transaction bytecode after signing. This should be set to the signed parameter found in the response object of the 'Sign a Transaction' Overledger action.",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+
+    const requestBody = {
+      requestId: this.requestId,
+      signedTransaction: this.signedTransaction,
+    };
+
+    const response = await this.overledger.executeSignedTransaction({
+      $,
+      environment: this.environment,
+      data: requestBody,
+    });
+
+    $.export("$summary", `Successfully executed signed transaction with Request ID ${this.requestId}`);
+    return response;
+  },
+};

package/actions/prepare-smart-contract-transaction/prepare-smart-contract-transaction.mjs

@@ -0,0 +1,83 @@
+import {
+  NETWORK_OPTIONS, TECHNOLOGY_OPTIONS,
+} from "../../common/constants.mjs";
+import { parseObject } from "../../common/utils.mjs";
+import overledger from "../../overledger.app.mjs";
+
+export default {
+  key: "overledger-prepare-smart-contract-transaction",
+  name: "Prepare Smart Contract Transaction",
+  description: "Prepares a smart contract transaction for signing on the Overledger platform. [See the documentation](https://developers.quant.network/reference/preparesmartcontractwrite)",
+  version: "0.0.2",
+  type: "action",
+  props: {
+    overledger,
+    environment: {
+      propDefinition: [
+        overledger,
+        "environment",
+      ],
+    },
+    locationTechnology: {
+      type: "string",
+      label: "Location Technology",
+      description: "The technology of the blockchain that the transaction will be submitted to",
+      options: TECHNOLOGY_OPTIONS,
+      reloadProps: true,
+    },
+    signingAccountId: {
+      type: "string",
+      label: "Signing Account ID",
+      description: "The blockchain account ID/address that will be sending this transaction",
+    },
+    smartContractId: {
+      type: "string",
+      label: "Smart Contract ID",
+      description: "The ID/address of the smart contract to interact with.",
+
+    },
+    functionName: {
+      type: "string",
+      label: "Function Name",
+      description: "The name of the function to call on the smart contract.",
+    },
+    inputParameters: {
+      type: "string[]",
+      label: "Input Parameters",
+      description: "The input parameters for the smart contract function, in JSON format.",
+      optional: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (this.locationTechnology) {
+      props.locationNetwork = {
+        type: "string",
+        label: "Location Network",
+        description: "The blockchain network the transaction will be submitted to.",
+        options: NETWORK_OPTIONS[this.locationTechnology],
+      };
+    }
+    return props;
+  },
+  async run({ $ }) {
+    const requestBody = {
+      location: {
+        technology: this.locationTechnology,
+        network: this.locationNetwork,
+      },
+      signingAccountId: this.signingAccountId,
+      functionName: this.functionName,
+      smartContractId: this.smartContractId,
+      inputParameters: parseObject(this.inputParameters), //parse these values using the parseObject function at this shouls turn the JSON string into JSON objects to used in the request body.
+    };
+
+    const response = await this.overledger.prepareSmartContractTransaction({
+      $,
+      environment: this.environment,
+      data: requestBody,
+    });
+    $.export("$summary", "Smart contract transaction prepared successfully");
+    return response;
+  },
+};

package/actions/read-from-a-smart-contract/read-from-a-smart-contract.mjs

@@ -0,0 +1,86 @@
+import {
+  NETWORK_OPTIONS, TECHNOLOGY_OPTIONS,
+} from "../../common/constants.mjs";
+import { parseObject } from "../../common/utils.mjs";
+import overledger from "../../overledger.app.mjs";
+
+export default {
+  key: "overledger-read-from-a-smart-contract",
+  name: "Read from a smart contract",
+  description: "Reads data from a specified smart contract on the Overledger network.",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    overledger,
+    environment: {
+      propDefinition: [
+        overledger,
+        "environment",
+      ],
+    },
+    locationTechnology: {
+      type: "string",
+      label: "Location Technology",
+      description: "The technology of the blockchain that the transaction will be submitted to",
+      options: TECHNOLOGY_OPTIONS,
+      reloadProps: true,
+    },
+    functionName: {
+      type: "string",
+      label: "Function Name",
+      description: "The name of the function to call on the smart contract.",
+    },
+    inputParameters: {
+      type: "string[]",
+      label: "Input Parameters",
+      description: "The input parameters for the smart contract function, provide both type and value in object format. Example: {\"type\":\"uint256\",\"value\":\"5\"} or {\"type\":\"address\",\"value\":\"0x3....ed8\"}",
+      optional: true,
+      default: [],
+    },
+    smartContractId: {
+      type: "string",
+      label: "Smart Contract ID",
+      description: "The ID/address of the smart contract to interact with.",
+    },
+    outputParameters: {
+      type: "string[]",
+      label: "Output Parameters",
+      description: "Each output parameter expected, provide just the type in object format. Example - 1) function returns one uint256 value: {\"type\": \"uint256\"} or 2) function returns two address values: {\"type\": \"address\"},{\"type\": \"address\"}",
+      optional: true,
+      default: [],
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (this.locationTechnology) {
+      props.locationNetwork = {
+        type: "string",
+        label: "Location Network",
+        description: "The blockchain network the transaction will be submitted to.",
+        options: NETWORK_OPTIONS[this.locationTechnology],
+      };
+    }
+    return props;
+  },
+  async run({ $ }) {
+
+    const requestBody = {
+      location: {
+        technology: this.locationTechnology,
+        network: this.locationNetwork,
+      },
+      functionName: this.functionName,
+      inputParameters: parseObject(this.inputParameters), //parse these values using the parseObject function at this shouls turn the JSON string into JSON objects to used in the request body.
+      smartContractId: this.smartContractId,
+      outputParameters: parseObject(this.outputParameters),
+    };
+      // Make the API call to Overledger
+    const response = await this.overledger.readFromSmartContract({
+      $,
+      environment: this.environment,
+      data: requestBody,
+    });
+    $.export("$summary", `Successfully read from contract: ${this.smartContractId}`);
+    return response;
+  },
+};

package/actions/sign-a-transaction/sign-a-transaction.mjs

@@ -0,0 +1,75 @@
+import overledger from "../../overledger.app.mjs";
+import { TECHNOLOGY_OPTIONS, UNIT_OPTIONS } from "../../common/constants.mjs";
+
+export default {
+  key: "overledger-sign-a-transaction",
+  name: "Sign a transaction",
+  description: "Sign a transaction using Overledger - Part 2 of [Overledger Pattern](https://developers.quant.network/reference/overledger-pattern). [See documentation](https://developers.quant.network/reference/sandboxsigning)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    overledger,
+    environment: {
+      propDefinition: [
+        overledger,
+        "environment",
+      ],
+    },
+    locationTechnology: {
+      type: "string",
+      label: "Location Technology",
+      description: "The blockchain technology used for this transaction, e.g., ethereum, substrate - required in order to set the dltfee",
+      options: TECHNOLOGY_OPTIONS,
+      reloadProps: true,
+    },
+    keyId: {
+      type: "string",
+      label: "Signing Account ID",
+      description: "The ID/address of the blockchain account that will sign the transaction.",
+    },
+    requestId: {
+      type: "string",
+      label: "Request ID",
+      description: "The Request ID assigned to a preparation request in Overledger. This should be set to the requestId parameter found in the response object of the 'Prepare Transaction' Overledger action.",
+    },
+    transactionSigningResponderName: {
+      type: "string",
+      label: "Transaction Signing Responder Name",
+      description: "The name of the Transaction Signing Responder you would like to use. The CTA Transaction Signing Responder is the Quant-provided signer for testnet accounts.",
+    },
+    nativeData: {
+      type: "object",
+      label: "Native Data",
+      description: "An object representing the transaction required to be signed - This should be set to the nativeData object of the 'Prepare Transaction' Overledger action.",
+    },
+  },
+  async run({ $ }) {
+    //default values of gatewayFee and dltfee hard coded into params.
+    const gatewayFee = {
+      amount: "0",
+      unit: "QNT",
+    };
+    // Define DLT Fee and dynamically set the 'unit/symbol' from UNIT_OPTIONS
+    const dltFee = {
+      amount: "0.000019897764079968",
+      unit: UNIT_OPTIONS[this.locationTechnology] || "ETH", // Use default if not found
+    };
+    // Sign the transaction
+    const requestBody = {
+      keyId: this.keyId,
+      gatewayFee: gatewayFee,
+      requestId: this.requestId,
+      dltFee: dltFee,
+      nativeData: this.nativeData,
+      transactionSigningResponderName: this.transactionSigningResponderName,
+    };
+
+    const response = await this.overledger.signTransaction({
+      $,
+      environment: this.environment,
+      data: requestBody,
+    });
+    $.export("$summary", "Transaction signed successfully");
+    return response;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,71 @@
+export const TECHNOLOGY_OPTIONS = [
+  {
+    label: "Ethereum",
+    value: "ethereum",
+  },
+  {
+    label: "Substrate",
+    value: "substrate",
+  },
+  {
+    label: "XRP Ledger",
+    value: "xrp ledger",
+  },
+  {
+    label: "Bitcoin",
+    value: "bitcoin",
+  },
+  {
+    label: "Hyperledger Fabric",
+    value: "hyperledger fabric",
+  },
+];
+
+export const NETWORK_OPTIONS = {
+  "ethereum": [
+    "ethereum sepolia testnet",
+    "ethereum goerli testnet",
+    "ethereum mainnet",
+    "polygon mumbai testnet",
+    "polygon mainnet",
+    "avalanche fuji testnet",
+    "avalanche c-chain mainnet",
+    "xdc apothem testnet",
+    "xdc network mainnet",
+    "Defined on demand",
+  ],
+  "substrate": [
+    "polkadot westend",
+    "polkadot mainnet",
+  ],
+  "xrp ledger": [
+    "testnet",
+    "mainnet",
+  ],
+  "bitcoin": [
+    "testnet",
+    "mainnet",
+  ],
+  "hyperledger fabric": [
+    "Sandbox",
+  ],
+};
+//Overledger environment to be used - Test or Live
+export const OVERLEDGER_INSTANCE = [
+  {
+    label: "Sandbox",
+    value: "sandbox",
+  },
+  {
+    label: "Overledger",
+    value: "overledger",
+  },
+];
+///unit options to allow for the correct selection based on the location network
+export const UNIT_OPTIONS = {
+  "ethereum": "ETH",               // Ethereum's token symbol is ETH
+  "substrate": "DOT",              // Polkadot's token symbol is DOT
+  "xrp ledger": "XRP",             // XRP Ledger's token symbol is XRP
+  "bitcoin": "BTC",                // Bitcoin's token symbol is BTC
+  "hyperledger fabric": "FAB",     // Placeholder for Hyperledger Fabric's token symbol
+};

package/common/utils.mjs

@@ -0,0 +1,18 @@
+export const parseObject = (obj) => {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      if (typeof item === "string") {
+        try {
+          return JSON.parse(item);
+        } catch (e) {
+          return item;
+        }
+      }
+      return item;
+    });
+  }
+  if (typeof obj === "string") {
+    return JSON.parse(obj);
+  }
+  return obj;
+};

package/overledger.app.mjs

@@ -1,11 +1,89 @@
+import { axios } from "@pipedream/platform";
+import { OVERLEDGER_INSTANCE } from "./common/constants.mjs";
+
 export default {
   type: "app",
   app: "overledger",
-  propDefinitions: {},
+  propDefinitions: {
+    smartContractId: {
+      type: "string",
+      label: "Smart Contract ID",
+      description: "The ID of the smart contract to interact with.",
+    },
+    environment: {
+      type: "string",
+      label: "Overledger Instance",
+      description: "Select the Overledger instance to be used",
+      options: OVERLEDGER_INSTANCE,
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    _headers() {
+      return {
+        "Authorization": `Bearer ${this.$auth.oauth_access_token}`,
+        "Content-Type": "application/json",
+        "API-Version": "3.0.0",
+      };
+    },
+    _getBaseUrl(environment) { //conditional for environment url selection.
+      return environment === "sandbox"
+        ? "https://api.sandbox.overledger.io"
+        : "https://api.overledger.io";
+    },
+    _makeRequest({
+      $ = this, environment, path, ...otherOpts
+    }) {
+      return axios($, {
+        ...otherOpts,
+        url: this._getBaseUrl(environment) + path,
+        headers: this._headers(),
+      });
+    },
+    prepareSmartContractTransaction(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/api/preparations/transactions/smart-contracts/write",
+        ...opts,
+      });
+    },
+    readFromSmartContract(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/api/smart-contracts/read",
+        ...opts,
+      });
+    },
+    signTransaction(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/api/transaction-signing-sandbox",
+        ...opts,
+      });
+    },
+    executeSignedTransaction(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/api/executions/transactions",
+        ...opts,
+      });
+    },
+    createHook({
+      path, ...opts
+    }) {
+      return this._makeRequest({
+        method: "POST",
+        path: `/api/webhooks/${path}`,
+        ...opts,
+      });
+    },
+    deleteHook({
+      path, webhookId, ...opts
+    }) {
+      return this._makeRequest({
+        method: "DELETE",
+        path: `/api/webhooks/${path}/${webhookId}`,
+        ...opts,
+      });
     },
   },
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/overledger",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Pipedream Overledger Components",
   "main": "overledger.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^1.5.1"
   }
 }

package/sources/common/base.mjs

@@ -0,0 +1,74 @@
+import {
+  NETWORK_OPTIONS, TECHNOLOGY_OPTIONS,
+} from "../../common/constants.mjs";
+import overledger from "../../overledger.app.mjs";
+
+export default {
+  props: {
+    overledger,
+    environment: {
+      propDefinition: [
+        overledger,
+        "environment",
+      ],
+    },
+    db: "$.service.db",
+    http: {
+      type: "$.interface.http",
+      customResponse: true,
+    },
+    locationTechnology: {
+      type: "string",
+      label: "Location Technology",
+      description: "The technology of the blockchain that the transaction will be submitted to",
+      options: TECHNOLOGY_OPTIONS,
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const props = {};
+    if (this.locationTechnology) {
+      props.locationNetwork = {
+        type: "string",
+        label: "Location Network",
+        description: "The blockchain network the transaction will be submitted to.",
+        options: NETWORK_OPTIONS[this.locationTechnology],
+      };
+    }
+    return props;
+  },
+  hooks: {
+    async activate() {
+      const response = await this.overledger.createHook({
+        path: this.getPath(),
+        environment: this.environment,
+        data: {
+          location: {
+            technology: this.locationTechnology,
+            network: this.locationNetwork,
+          },
+          callbackUrl: this.http.endpoint,
+          ...this.additionalData(),
+        },
+      });
+      this.db.set("webhookId", response.webhookId);
+    },
+    async deactivate() {
+      const webhookId = this.db.get("webhookId");
+      await this.overledger.deleteHook({
+        path: this.getPath(),
+        webhookId,
+        environment: this.environment,
+      });
+    },
+  },
+  async run(event) {
+    const { body } = event;
+
+    this.$emit(body, {
+      id: body.transactionId || body?.smartContractEventUpdateDetails?.nativeData?.transactionHash,
+      summary: this.getSummary(body),
+      ts: Date.now(),
+    });
+  },
+};

package/sources/new-contract-event-instant/new-contract-event-instant.mjs

@@ -0,0 +1,35 @@
+import common from "../common/base.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  ...common,
+  key: "overledger-new-contract-event-instant",
+  name: "New Smart Contract Event (Instant)",
+  description: "Emit new event when a smart contract releases a new event.",
+  version: "0.0.2",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    smartContractId: {
+      propDefinition: [
+        common.props.overledger,
+        "smartContractId",
+      ],
+    },
+  },
+  methods: {
+    getPath() {
+      return "smart-contract-events";
+    },
+    additionalData() {
+      return {
+        smartContractId: this.smartContractId,
+      };
+    },
+    getSummary(body) {
+      return `New contract event with transaction Hash: ${body?.smartContractEventUpdateDetails?.nativeData?.transactionHash}`;
+    },
+  },
+  sampleEmit,
+};

package/sources/new-contract-event-instant/test-event.mjs

@@ -0,0 +1,24 @@
+export default {
+  "type": "smartContractEvent",
+  "webhookId": "6c964253-4b10-43a5-a812-9b30e92275a3",
+  "location": {
+    "technology": "ethereum",
+    "network": "polygon mumbai testnet"
+  },
+  "smartContractEventUpdateDetails": {
+    "smartContractId": "0x8590d37d55049de2555f0f9541325e7fe6b19b17",
+    "nativeData": {
+      "removed": false,
+      "logIndex": 0,
+      "transactionIndex": 0,
+      "transactionHash": "0xde2bbf9704d726ff395eb78217e9acb226b0ecb0b609021cccd7e67d99763db2",
+      "blockHash": "0x6d1a13d15fd0a90f361d3e368830bbe45c628382c4533d10f1a23ae699c781cc",
+      "blockNumber": "0x28b2471",
+      "address": "0x8590d37d55049de2555f0f9541325e7fe6b19b17",
+      "data": "0x0000000000000000000000001789d90438333751fdcca0d03d8952168b99ef02",
+      "topics": [
+        "0x2d1801d4e6df986759c8582affebc974bcf0cacfd5d2ab120eb776efa53dffa2"
+      ]
+    }
+  }
+}

package/sources/watch-new-account-event-instant/test-event.mjs

@@ -0,0 +1,10 @@
+export default {  
+  "type": "account",  
+  "webhookId": "20f6ce08-04b4-4ce4-94eb-e2304a0737af",  
+  "accountId": "0x282f70d5af34aedaac479b12a08e189bbee83066",  
+  "location": {  
+    "technology": "ethereum",  
+    "network": "polygon mumbai testnet"  
+  },  
+  "transactionId": "0xd65c16e476a5ad5fa89ffe14512bd7984e575a4370ac86ccfb88202da20f9262"  
+}

package/sources/watch-new-account-event-instant/watch-new-account-event-instant.mjs

@@ -0,0 +1,34 @@
+import common from "../common/base.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  ...common,
+  key: "overledger-watch-new-account-event-instant",
+  name: "New Account Event (Instant)",
+  description: "Emit new event for transactions to/from a specific account.",
+  version: "0.0.2",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    accountId: {
+      type: "string",
+      label: "Account Id",
+      description: "The blockchain account that will be monitored for transaction updates.",
+    },
+  },
+  methods: {
+    getPath() {
+      return "accounts";
+    },
+    additionalData() {
+      return {
+        accountId: this.accountId,
+      };
+    },
+    getSummary(body) {
+      return `New account event with transaction Id: ${body.transactionId}`;
+    },
+  },
+  sampleEmit,
+};