@develit-services/blockchain 0.8.2 → 0.8.4

package/dist/shared/{blockchain.DZbyq0JM.d.mts → blockchain.DcWSUM60.d.mts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { s as schema } from './blockchain.Cx60lJ0c.mjs';
+import { s as schema } from './blockchain.DUhjXgba.mjs';
 
 declare const getBlockInputSchema: z.ZodObject<{
     chain: z.ZodEnum<{
@@ -12,9 +12,9 @@ declare const getBlockInputSchema: z.ZodObject<{
         SCROLL: "SCROLL";
     }>;
     blockTag: z.ZodOptional<z.ZodEnum<{
-        pending: "pending";
         latest: "latest";
         earliest: "earliest";
+        pending: "pending";
         safe: "safe";
         finalized: "finalized";
     }>>;
@@ -93,9 +93,9 @@ declare const getTransactionOutputSchema: z.ZodObject<{
     nonce: z.ZodNumber;
     transactionIndex: z.ZodNullable<z.ZodNumber>;
     status: z.ZodEnum<{
+        pending: "pending";
         success: "success";
         reverted: "reverted";
-        pending: "pending";
     }>;
     gasUsed: z.ZodNullable<z.ZodString>;
     timestamp: z.ZodNullable<z.ZodNumber>;

package/dist/shared/{blockchain.5Ld6uEay.d.ts → blockchain.DurPotrN.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { s as schema } from './blockchain.Cx60lJ0c.js';
+import { s as schema } from './blockchain.DUhjXgba.js';
 
 declare const getBlockInputSchema: z.ZodObject<{
     chain: z.ZodEnum<{
@@ -12,9 +12,9 @@ declare const getBlockInputSchema: z.ZodObject<{
         SCROLL: "SCROLL";
     }>;
     blockTag: z.ZodOptional<z.ZodEnum<{
-        pending: "pending";
         latest: "latest";
         earliest: "earliest";
+        pending: "pending";
         safe: "safe";
         finalized: "finalized";
     }>>;
@@ -93,9 +93,9 @@ declare const getTransactionOutputSchema: z.ZodObject<{
     nonce: z.ZodNumber;
     transactionIndex: z.ZodNullable<z.ZodNumber>;
     status: z.ZodEnum<{
+        pending: "pending";
         success: "success";
         reverted: "reverted";
-        pending: "pending";
     }>;
     gasUsed: z.ZodNullable<z.ZodString>;
     timestamp: z.ZodNullable<z.ZodNumber>;

package/dist/shared/blockchain.JBv4ipVR.cjs

@@ -0,0 +1,335 @@
+'use strict';
+
+const database_schema = require('./blockchain.ZJPECySM.cjs');
+require('drizzle-orm');
+const backendSdk = require('@develit-io/backend-sdk');
+const viem = require('viem');
+const accounts = require('viem/accounts');
+
+const tables = database_schema.schema;
+
+class IBlockchainConnector {
+}
+
+const TRANSFER_EVENT_ABI = [
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "value", type: "uint256" }
+    ]
+  }
+];
+const ERC20_TRANSFER_ABI = [
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+class EvmConnector extends IBlockchainConnector {
+  constructor(config) {
+    super();
+    this.client = null;
+    this.rpcUrl = config.RPC_URL;
+    this.tokens = config.tokens;
+    this.connectedAddresses = config.connectedAddresses;
+    this.resolveCredentials = config.resolveCredentials;
+  }
+  createClient() {
+    if (!this.client) {
+      this.client = viem.createPublicClient({
+        transport: viem.http(this.rpcUrl)
+      });
+    }
+    return this.client;
+  }
+  async getTransaction(txHash) {
+    const client = this.createClient();
+    const [tx, txError] = await backendSdk.useResult(
+      client.getTransaction({ hash: txHash })
+    );
+    if (txError || !tx) {
+      throw backendSdk.createInternalError(txError);
+    }
+    let status = "pending";
+    let gasUsed = null;
+    let timestamp = null;
+    if (tx.blockNumber) {
+      const [receipt, receiptError] = await backendSdk.useResult(
+        client.getTransactionReceipt({ hash: txHash })
+      );
+      if (receiptError || !receipt) {
+        throw backendSdk.createInternalError(receiptError);
+      }
+      const [block, blockError] = await backendSdk.useResult(
+        client.getBlock({ blockNumber: tx.blockNumber })
+      );
+      if (blockError || !block) {
+        throw backendSdk.createInternalError(blockError);
+      }
+      status = receipt.status === "success" ? "success" : "reverted";
+      gasUsed = receipt.gasUsed.toString();
+      timestamp = Number(block.timestamp) * 1e3;
+    }
+    return {
+      hash: tx.hash,
+      from: tx.from,
+      to: tx.to,
+      value: tx.value.toString(),
+      blockNumber: tx.blockNumber?.toString() ?? null,
+      blockHash: tx.blockHash ?? null,
+      gasPrice: tx.gasPrice?.toString() ?? null,
+      gas: tx.gas.toString(),
+      nonce: tx.nonce,
+      transactionIndex: tx.transactionIndex,
+      status,
+      gasUsed,
+      timestamp
+    };
+  }
+  async getTransactionReceipt(txHash) {
+    const client = this.createClient();
+    const [receipt, error] = await backendSdk.useResult(
+      client.getTransactionReceipt({ hash: txHash })
+    );
+    if (error || !receipt) {
+      throw backendSdk.createInternalError(error);
+    }
+    return receipt;
+  }
+  async getBlock({
+    blockHash,
+    blockNumber,
+    blockTag
+  }) {
+    const client = this.createClient();
+    const [block, error] = await backendSdk.useResult(
+      blockHash !== void 0 ? client.getBlock({ blockHash }) : blockNumber !== void 0 ? client.getBlock({ blockNumber }) : client.getBlock({ blockTag: blockTag ?? "finalized" })
+    );
+    if (error || !block) {
+      throw error;
+    }
+    return block;
+  }
+  async getAllAddressTransactions({
+    address,
+    filter
+  }) {
+    const client = this.createClient();
+    const latestBlock = await client.getBlockNumber();
+    const transactions = [];
+    const allTransactionsFromContracts = await Promise.all(
+      this.tokens.map(async (token) => {
+        const events = await client.getContractEvents({
+          abi: TRANSFER_EVENT_ABI,
+          address: token.smartContractAddress,
+          eventName: "Transfer",
+          args: {
+            to: address
+          },
+          fromBlock: filter.fromBlock ?? latestBlock - 900n,
+          toBlock: "latest"
+        });
+        return { events, token };
+      })
+    );
+    for (const { events, token } of allTransactionsFromContracts) {
+      for (const tx of events) {
+        const [receipt, block] = await Promise.all([
+          client.getTransactionReceipt({ hash: tx.transactionHash }),
+          client.getBlock({ blockNumber: tx.blockNumber })
+        ]);
+        transactions.push({
+          hash: tx.transactionHash,
+          from: tx.args.from ?? "",
+          to: tx.args.to ?? "",
+          value: (tx.args.value ?? 0n).toString(),
+          blockNumber: tx.blockNumber.toString(),
+          blockHash: tx.blockHash,
+          gasUsed: receipt.gasUsed.toString(),
+          gasPrice: receipt.effectiveGasPrice?.toString() ?? "",
+          timestamp: Number(block.timestamp),
+          status: receipt.status,
+          decimals: token.decimals,
+          connector: this.connectorKey,
+          ticker: token.ticker
+        });
+      }
+    }
+    return { transactions, latestBlock };
+  }
+  async sendTransaction({
+    from,
+    to,
+    value,
+    token
+  }) {
+    const address = this.connectedAddresses.find(
+      (a) => a.number.toLowerCase() === from.toLowerCase()
+    );
+    if (!address) {
+      throw backendSdk.createInternalError(null, {
+        message: `Address not found: ${from}`
+      });
+    }
+    if (!this.resolveCredentials) {
+      throw backendSdk.createInternalError(null, {
+        message: `Credentials resolver not provided`
+      });
+    }
+    const credentials = await this.resolveCredentials(address.id);
+    if (!credentials) {
+      throw backendSdk.createInternalError(null, {
+        message: `No private key found for address: ${from}`
+      });
+    }
+    const account = accounts.privateKeyToAccount(credentials.value);
+    const walletClient = viem.createWalletClient({
+      account,
+      transport: viem.http(this.rpcUrl)
+    });
+    let hash;
+    if (token) {
+      const data = viem.encodeFunctionData({
+        abi: ERC20_TRANSFER_ABI,
+        functionName: "transfer",
+        args: [to, viem.parseUnits(value, token.decimals)]
+      });
+      hash = await walletClient.sendTransaction({
+        chain: null,
+        to: token.smartContractAddress,
+        data
+      });
+    } else {
+      hash = await walletClient.sendTransaction({
+        chain: null,
+        to,
+        value: BigInt(value)
+      });
+    }
+    return { hash };
+  }
+}
+
+class ArbitrumConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "ARBITRUM";
+  }
+}
+
+class AvalancheConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "AVALANCHE";
+  }
+}
+
+class BaseConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "BASE";
+  }
+}
+
+class EthereumConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "ETHEREUM";
+  }
+}
+
+class GnosisConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "GNOSIS";
+  }
+}
+
+class OptimismConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "OPTIMISM";
+  }
+}
+
+class ScrollConnector extends EvmConnector {
+  constructor(config) {
+    super(config);
+    this.connectorKey = "SCROLL";
+  }
+}
+
+const initiateConnector = async ({
+  chain,
+  env,
+  tokens,
+  connectedAddresses,
+  resolveCredentials
+}) => {
+  const getRpcUrl = async (secretName) => (await env.SECRETS_STORE.get({ secretName })).data?.secretValue || "";
+  switch (chain) {
+    case "ETHEREUM":
+      return new EthereumConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_ETHEREUM_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "ARBITRUM":
+      return new ArbitrumConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_ARBITRUM_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "AVALANCHE":
+      return new AvalancheConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_AVALANCHE_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "BASE":
+      return new BaseConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_BASE_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "GNOSIS":
+      return new GnosisConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_GNOSIS_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "OPTIMISM":
+      return new OptimismConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_OPTIMISM_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    case "SCROLL":
+      return new ScrollConnector({
+        RPC_URL: await getRpcUrl("BLOCKCHAIN_SERVICE_SCROLL_RPC_URL"),
+        tokens,
+        connectedAddresses,
+        resolveCredentials
+      });
+    default:
+      throw new Error(`Unsupported chain: ${chain}`);
+  }
+};
+
+exports.initiateConnector = initiateConnector;
+exports.tables = tables;

package/dist/shared/blockchain.ZJPECySM.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+const backendSdk = require('@develit-io/backend-sdk');
+const sqliteCore = require('drizzle-orm/sqlite-core');
+const syncAddress = require('./blockchain.Cjq9eH7Z.cjs');
+
+const address = sqliteCore.sqliteTable("address", {
+  ...backendSdk.base,
+  number: sqliteCore.text("number").notNull(),
+  syncIntervalS: sqliteCore.integer("sync_interval_s").notNull().default(600),
+  lastSyncBlock: sqliteCore.blob("last_sync_block", { mode: "bigint" }),
+  lastSyncAt: sqliteCore.integer("last_sync_at", { mode: "timestamp_ms" }),
+  lastSyncMetadata: sqliteCore.text("last_sync_metadata", {
+    mode: "json"
+  }).$type(),
+  connector: sqliteCore.text("connector").$type()
+});
+
+const addressCredentials = sqliteCore.sqliteTable("address_credentials", {
+  ...backendSdk.base,
+  addressId: sqliteCore.text("address_id").references(() => address.id, { onDelete: "restrict", onUpdate: "cascade" }).notNull(),
+  connector: sqliteCore.text("connector", {
+    enum: syncAddress.CHAIN_KEYS
+  }).$type().notNull(),
+  type: sqliteCore.text("type", {
+    enum: syncAddress.CREDENTIALS_TYPES
+  }).$type().notNull(),
+  value: sqliteCore.text("value").notNull(),
+  expiresAt: sqliteCore.integer("expires_at", { mode: "timestamp_ms" })
+});
+
+const tokens = sqliteCore.sqliteTable("tokens", {
+  ...backendSdk.base,
+  smartContractAddress: sqliteCore.text("smart_contract_address").$type().notNull(),
+  connector: sqliteCore.text("connector").$type(),
+  ticker: sqliteCore.text("ticker").notNull(),
+  decimals: sqliteCore.integer("decimals").notNull(),
+  name: sqliteCore.text("name")
+});
+
+const transaction = sqliteCore.sqliteTable(
+  "transaction",
+  {
+    ...backendSdk.base,
+    hash: sqliteCore.text("hash"),
+    from: sqliteCore.text("from"),
+    to: sqliteCore.text("to"),
+    value: sqliteCore.text("value"),
+    blockNumber: sqliteCore.text("block_number"),
+    blockHash: sqliteCore.text("blockHash"),
+    gasUsed: sqliteCore.text("gasUsed"),
+    gasPrice: sqliteCore.text("gasPrice"),
+    timestamp: sqliteCore.integer("timestamp"),
+    status: sqliteCore.text("status"),
+    decimals: sqliteCore.integer("decimals"),
+    connector: sqliteCore.text("connector").$type(),
+    ticker: sqliteCore.text("ticker")
+  },
+  (t) => [sqliteCore.uniqueIndex("transaction_hash_unique").on(t.hash)]
+);
+
+const schema = {
+  __proto__: null,
+  address: address,
+  addressCredentials: addressCredentials,
+  tokens: tokens,
+  transaction: transaction
+};
+
+exports.address = address;
+exports.addressCredentials = addressCredentials;
+exports.schema = schema;
+exports.tokens = tokens;
+exports.transaction = transaction;