From 36c9954d5a2c6a2472ebe6f7c1618286240cf124 Mon Sep 17 00:00:00 2001
From: Suprun <hello@syoma.website>
Date: Fri, 10 Jan 2025 22:22:53 +0300
Subject: [PATCH] chore: refactor DevTools

split component to separated modules
---
 .../DevTools/ContractManageForm.vue           | 400 ++---------------
 src/components/Fields/FieldList.vue           |  59 +++
 src/components/Fields/SliceField.vue          |  23 +-
 src/i18n/en.json                              |   1 -
 src/i18n/ru.json                              |   1 -
 src/tonVerifier/consts.ts                     |  14 +
 src/tonVerifier/index.ts                      | 123 +++++
 src/tonVerifier/registry.ts                   |  24 +
 src/utils/devTools.ts                         | 420 ++++++++++++++++++
 src/utils/retry.ts                            |  17 +
 src/utils/tonHelpers.ts                       |  48 ++
 src/views/DevTools.vue                        | 175 ++------
 12 files changed, 785 insertions(+), 520 deletions(-)
 create mode 100644 src/components/Fields/FieldList.vue
 create mode 100644 src/tonVerifier/consts.ts
 create mode 100644 src/tonVerifier/index.ts
 create mode 100644 src/tonVerifier/registry.ts
 create mode 100644 src/utils/devTools.ts
 create mode 100644 src/utils/retry.ts
 create mode 100644 src/utils/tonHelpers.ts

diff --git a/src/components/DevTools/ContractManageForm.vue b/src/components/DevTools/ContractManageForm.vue
index 9658ec7..3b43e5d 100644
--- a/src/components/DevTools/ContractManageForm.vue
+++ b/src/components/DevTools/ContractManageForm.vue
@@ -1,29 +1,14 @@
 <template>
   <h2 class="subtitle">{{ title || $t("message.DevTools.ChooseOperation") }}</h2>
 
-  <div v-if="!abi.type">
+  <div v-if="!title">
     {{ $t("message.DevTools.DefaultText") }}
   </div>
 
 
-  <div v-for="(input, index) in inputs" v-bind:key="`${title}_${index}`">
-    <StringField v-if="input.type == 'string'" v-bind="input" :ref="el => refItems.push(el as BaseFieldElement)" />
-    <CoinsField v-else-if="input.type == 'uint' && input.format == 'coins'" v-bind="input"
-      :ref="el => refItems.push(el as BaseFieldElement)" />
-    <UintField v-else-if="input.type == 'uint'" v-bind="input" :ref="el => refItems.push(el as BaseFieldElement)" />
-    <SliceField v-else-if="input.type == 'slice'" v-bind="input" :ref="el => refItems.push(el as BaseFieldElement)" />
-    <AddressField v-else-if="input.type == 'address'" v-bind="input"
-      :ref="el => refItems.push(el as BaseFieldElement)" />
-    <BooleanField v-else-if="input.type == 'bool'" v-bind="input" :ref="el => refItems.push(el as BaseFieldElement)" />
-    <UnknownField v-else v-bind="input" :ref="el => refItems.push(el as BaseFieldElement)" />
-  </div>
+  <FieldList :form-title="title ?? 'title'" :inputs="inputs" :register-element="registerElement" />
 
-  <div v-if="abi.type == 'getter'" class="control">
-    <button class="button is-link" @click="computeGetter">Compute</button>
-  </div>
-  <div v-if="abi.type == 'receiver'" class="control">
-    <button class="button is-primary" @click="sendTransaction">Send transaction</button>
-  </div>
+  <button class="button is-primary" @click="execute">Execute</button>
 
   <div v-if="getterResult" class="content">
     <ul>
@@ -34,52 +19,12 @@
 </template>
 
 <script lang="ts">
-import { beginCell, Builder, toNano, type ABIGetter, type ABIReceiver, type ABIType, type ContractProvider, type TupleItem } from 'ton-core';
-import StringField from '../Fields/StringField.vue';
-import CoinsField from '../Fields/CoinsField.vue';
-import UintField from '../Fields/UintField.vue';
-import UnknownField from '../Fields/UnknownField.vue';
-import SliceField from '../Fields/SliceField.vue';
-import AddressField from '../Fields/AddressField.vue';
-import BooleanField from '../Fields/BooleanField.vue';
-import type { CreateComponentPublicInstanceWithMixins } from 'vue';
-
-type BaseFieldElement = CreateComponentPublicInstanceWithMixins<{
-  validate(): boolean,
-  store(builder: Builder): void,
-}>;
-
-interface BaseFieldInput {
-  optional: boolean,
-  label: string,
-  placeholder?: string
-  helpText?: string
-}
-
-type AnyFieldInput = { type: "any" } & BaseFieldInput;
-type EmptyFieldInput = { type: "empty" } & BaseFieldInput;
-type TextFieldInput = { type: "text" } & BaseFieldInput;
-type CoinsFieldInput = { type: "uint", format: "coins" } & BaseFieldInput;
-type UintFieldInput = { type: "uint", format: number } & BaseFieldInput;
-type StringFieldInput = { type: "string" } & BaseFieldInput;
-type SliceFieldInput = { type: "slice" } & BaseFieldInput;
-type AddressFieldInput = { type: "address" } & BaseFieldInput;
-type BoolFieldInput = { type: "bool" } & BaseFieldInput;
-type UnknownFieldInput = { type: "unknown", expected: string } & BaseFieldInput;
-
-type InputItem = AnyFieldInput
-  | EmptyFieldInput
-  | TextFieldInput
-  | CoinsFieldInput
-  | UintFieldInput
-  | StringFieldInput
-  | SliceFieldInput
-  | AddressFieldInput
-  | BoolFieldInput
-  | UnknownFieldInput;
+import { toNano, type ABIGetter, type ABIReceiver, type ABIType, type ContractProvider } from 'ton-core';
+import FieldList from '../Fields/FieldList.vue';
+import { BaseDevTools, GetterDevTools, ReceiverDevTools, type BaseFieldElement } from '@/utils/devTools';
 
 export default {
-  components: { StringField, CoinsField, UintField, SliceField, AddressField, BooleanField, UnknownField },
+  components: { FieldList },
   props: {
     types: {
       type: Object as () => ABIType[],
@@ -92,328 +37,41 @@ export default {
   },
   data() {
     return {
-      abi: {} as { type: "receiver", receiver: ABIReceiver } | { type: "getter", getter: ABIGetter },
+      devTools: new BaseDevTools(),
       getterResult: [] as { type: string, value: string }[],
-      refItems: [] as BaseFieldElement[],
     }
   },
-  beforeUpdate() {
-    this.refItems = [];
-  },
   computed: {
     title() {
-      if (this.abi.type == "getter") {
-        return this.abi.getter.name
-      }
-
-      if (this.abi.type == "receiver" && this.abi.receiver.message.kind == "typed") {
-        return this.abi.receiver.message.type
-      }
-
-      return null
+      return this.devTools.getTitle();
+    },
+    inputs() {
+      return this.devTools.getFields();
     },
-    inputs(): InputItem[] {
-      const result = [] as InputItem[];
-
-      if (this.abi.type == "getter" && this.abi.getter.arguments) {
-        for (const argument of this.abi.getter.arguments) {
-          switch (argument.type.kind) {
-            case "dict":
-              result.push({
-                type: "unknown",
-                expected: "dict",
-                optional: false,
-                label: argument.name,
-              });
-              // TODO
-              break;
-            case "simple":
-              switch (argument.type.type) {
-                // TODO
-                case "string":
-                  result.push({
-                    type: "string",
-                    optional: argument.type.optional || false,
-                    label: argument.name
-                  });
-                  break;
-                case "uint":
-                  if (argument.type.format == "coins") {
-                    result.push({
-                      type: "uint",
-                      format: "coins",
-                      optional: argument.type.optional || false,
-                      label: argument.name
-                    });
-                  }
-                  else if (typeof argument.type.format == 'number') {
-                    result.push({
-                      type: "uint",
-                      format: argument.type.format,
-                      optional: argument.type.optional || false,
-                      label: argument.name
-                    });
-                  }
-                  else {
-                    result.push({
-                      type: "unknown",
-                      expected: "uint with" + argument.type.format,
-                      optional: false,
-                      label: argument.name,
-                    });
-                  }
-                  break;
-                case "slice":
-                  result.push({
-                    type: "slice",
-                    optional: false,
-                    label: argument.name,
-                  })
-                  break;
-                case "address":
-                  result.push({
-                    type: "address",
-                    optional: false,
-                    label: argument.name,
-                  })
-                  break;
-                case "bool":
-                  result.push({
-                    type: "bool",
-                    optional: true,
-                    label: argument.name,
-                  })
-                  break;
-                default:
-                  result.push({
-                    type: "unknown",
-                    expected: argument.type.type,
-                    optional: false,
-                    label: argument.name,
-                  });
-                  break;
-              }
-          }
-        }
-      }
-
-      if (this.abi.type == "receiver") {
-        switch (this.abi.receiver.message.kind) {
-          case "any":
-            result.push({
-              type: "any",
-              optional: false,
-              label: "Any message" // TODO translate
-            })
-            // TODO support any
-            break;
-          case "empty":
-            result.push({
-              type: "empty",
-              optional: false,
-              label: "Empty message" // TODO translate
-            })
-            // TODO support empty
-            break;
-          case "text":
-            result.push({
-              type: "text",
-              optional: false,
-              label: "Text message" // TODO translate
-            })
-            // TODO support empty
-            break;
-          case "typed":
-            const typeName = this.abi.receiver.message.type;
-            const type = this.types.find((value) => value.name === typeName);
-            if (type) {
-              for (const field of type.fields) {
-                switch (field.type.kind) {
-                  case "dict":
-                    result.push({
-                      type: "unknown",
-                      expected: "dict",
-                      optional: false,
-                      label: field.name,
-                    });
-                    // TODO support dict
-                    break;
-                  case "simple":
-                    switch (field.type.type) {
-                      // TODO
-                      case "string":
-                        result.push({
-                          type: "string",
-                          optional: field.type.optional || false,
-                          label: field.name
-                        });
-                        break;
-                      case "uint":
-                        if (field.type.format == "coins") {
-                          result.push({
-                            type: "uint",
-                            format: "coins",
-                            optional: field.type.optional || false,
-                            label: field.name
-                          });
-                        }
-                        else if (typeof field.type.format == 'number') {
-                          result.push({
-                            type: "uint",
-                            format: field.type.format,
-                            optional: field.type.optional || false,
-                            label: field.name
-                          });
-                        }
-                        else {
-                          result.push({
-                            type: "unknown",
-                            expected: "uint with" + field.type.format,
-                            optional: false,
-                            label: field.name,
-                          });
-                        }
-                        break;
-                      case "slice":
-                        result.push({
-                          type: "slice",
-                          optional: false,
-                          label: field.name,
-                        })
-                        break;
-                      case "address":
-                        result.push({
-                          type: "address",
-                          optional: false,
-                          label: field.name,
-                        })
-                        break;
-                      case "bool":
-                        result.push({
-                          type: "bool",
-                          optional: true,
-                          label: field.name,
-                        })
-                        break;
-                      default:
-                        result.push({
-                          type: "unknown",
-                          expected: field.type.type,
-                          optional: false,
-                          label: field.name,
-                        });
-                        break;
-                    }
-                    // TODO
-                    break;
-                }
-              }
-            }
-        }
-      }
-
-      return result;
-    }
   },
   methods: {
     setGetter(getter: ABIGetter) {
-      this.getterResult = [];
-      this.abi = { type: "getter", getter }
+      this.devTools = new GetterDevTools({
+        getter,
+        types: this.types,
+        provider: this.provider,
+      });
     },
     setReceiver(receiver: ABIReceiver) {
-      this.getterResult = [];
-      this.abi = { type: "receiver", receiver }
+      this.devTools = new ReceiverDevTools({
+        receiver,
+        types: this.types,
+        address: this.$route.params.address as string,
+        tonConnectUI: this.$tonConnectUI,
+        tonAmount: toNano("0.1")
+      });
     },
-    async computeGetter() {
-      this.getterResult = [];
-
-      if (this.abi.type !== "getter") {
-        return;
-      }
-
-      this.refItems = this.refItems.filter(item => !!item);
-      if (this.refItems.map((item) => item.validate()).filter(item => !item).length > 0) {
-        return false;
-      }
-
-      const args = [] as TupleItem[];
-      for (const input of this.refItems) {
-        args.push({
-          type: "slice",
-          cell: beginCell().store(input.store).endCell()
-        })
-        // TODO
-      }
-
-      const provider = await this.provider.get(this.abi.getter.name, args);
-      const providerLength = provider.stack.remaining;
-
-      this.getterResult = [];
-      for (let i = 0; i < providerLength; i++) {
-        const item = provider.stack.pop();
-        switch (item.type) {
-          case "int":
-            this.getterResult.push({
-              type: item.type,
-              value: item.value.toString()
-            });
-            break;
-          case "cell":
-          case "slice":
-          case "builder":
-            this.getterResult.push({
-              type: item.type,
-              value: item.cell.toBoc().toString("base64"),
-            });
-            break;
-          default:
-            this.getterResult.push({
-              type: item.type,
-              value: "No value",
-            });
-            break
-        }
-      }
+    registerElement(el: BaseFieldElement) {
+      this.devTools.registerInput(el);
+    },
+    async execute() {
+      this.devTools.execute()
     },
-    async sendTransaction() {
-      if (this.abi.type !== "receiver" || this.abi.receiver.message.kind !== "typed") {
-        return;
-      }
-
-      this.refItems = this.refItems.filter(item => !!item);
-      if (this.refItems.map((item) => item.validate()).filter(item => !item).length > 0) {
-        return false;
-      }
-
-      const typeName = this.abi.receiver.message.type;
-      const type = this.types.find((value) => value.name === typeName);
-      if (!type) {
-        return;
-      }
-
-      const tx = beginCell();
-
-      if (type.header) {
-        tx.storeUint(type.header, 32);
-      }
-
-      for (const input of this.refItems) {
-        tx.store(input.store);
-      }
-
-      await this.$tonConnectUI.sendTransaction(
-        {
-          validUntil: Math.floor(Date.now() / 1000) + 360,
-          messages: [
-            {
-              address: this.$route.params.address as string,
-              amount: toNano("0.1").toString(),
-              payload: tx.endCell().toBoc().toString("base64"),
-            }
-          ]
-        }
-      )
-    }
   }
 }
 </script>
\ No newline at end of file
diff --git a/src/components/Fields/FieldList.vue b/src/components/Fields/FieldList.vue
new file mode 100644
index 0000000..59af32b
--- /dev/null
+++ b/src/components/Fields/FieldList.vue
@@ -0,0 +1,59 @@
+<template>
+  <div v-for="(input, index) in inputs" v-bind:key="`${formTitle}_${index}`">
+    <StringField v-if="input.type == 'string'" v-bind="input"
+      :ref="el => registerElement(index, el as BaseFieldElement)" />
+    <CoinsField v-else-if="input.type == 'uint' && input.format == 'coins'" v-bind="input"
+      :ref="el => registerElement(index, el as BaseFieldElement)" />
+    <UintField v-else-if="input.type == 'uint'" v-bind="input"
+      :ref="el => registerElement(index, el as BaseFieldElement)" />
+    <SliceField v-else-if="input.type == 'slice'" v-bind="input"
+      :ref="el => registerElement(index, el as BaseFieldElement)" />
+    <AddressField v-else-if="input.type == 'address'" v-bind="input"
+      :ref="el => registerElement(index, el as BaseFieldElement)" />
+    <BooleanField v-else-if="input.type == 'bool'" v-bind="input"
+      :ref="el => registerElement(index, el as BaseFieldElement)" />
+    <!-- <UnknownField v-else v-bind="input" :ref="el => registerElement(index, el as BaseFieldElement)" /> -->
+  </div>
+</template>
+
+<script lang="ts">
+import type { Builder } from 'ton-core';
+import type { CreateComponentPublicInstanceWithMixins } from 'vue';
+import type { InputItem } from '@/utils/devTools';
+import StringField from './StringField.vue';
+import CoinsField from './CoinsField.vue';
+import UintField from './UintField.vue';
+import SliceField from './SliceField.vue';
+import AddressField from './AddressField.vue';
+import BooleanField from './BooleanField.vue';
+import UnknownField from './UnknownField.vue';
+
+type BaseFieldElement = CreateComponentPublicInstanceWithMixins<{
+  validate(): boolean,
+  store(builder: Builder): void,
+}>;
+
+export default {
+  components: { StringField, CoinsField, UintField, SliceField, AddressField, BooleanField, UnknownField },
+  props: {
+    formTitle: {
+      type: String,
+      required: true,
+    },
+    inputs: {
+      type: Object as () => InputItem[],
+      required: true,
+    },
+  },
+  computed: {
+    registerElement(index: number, el: BaseFieldElement) {
+      //
+    }
+  },
+  data() {
+    return {
+      fields: [] as BaseFieldElement[],
+    }
+  }
+}
+</script>
\ No newline at end of file
diff --git a/src/components/Fields/SliceField.vue b/src/components/Fields/SliceField.vue
index bd46253..18d8a67 100644
--- a/src/components/Fields/SliceField.vue
+++ b/src/components/Fields/SliceField.vue
@@ -1,7 +1,24 @@
 <template>
-  <TextInput ref="input" :optional="optional" :label="label"
-    :placeholder="placeholder || $t('message.Fields.Slice_Placeholder')"
-    :help-text="helpText || $t('message.Fields.Slice_HelpText')" />
+  <strong>Slice</strong>
+
+  <article class="message">
+    <div class="message-body">
+      <div class="field has-addons">
+        <div class="control is-expanded">
+          <div class="select is-fullwidth">
+            <select name="type">
+              <option value="string">string</option>
+              <option value="uint">uint</option>
+              <option value="coins">coins</option>
+            </select>
+          </div>
+        </div>
+        <div class="control">
+          <button type="submit" class="button is-primary">Add field</button>
+        </div>
+      </div>
+    </div>
+  </article>
 </template>
 
 <script lang="ts">
diff --git a/src/i18n/en.json b/src/i18n/en.json
index 733a296..91b8d81 100644
--- a/src/i18n/en.json
+++ b/src/i18n/en.json
@@ -87,7 +87,6 @@
     "DevTools": {
       "SearchButton": "Search",
       "SearchText": "Open contract by address",
-      "DifferentContract": "This jetton is not deployed via this website. So it may have different logic and this website may display its data incorrectly.",
       "AdminAddress": "Admin address",
       "TotalSupply": "Total supply",
       "Receivers": "Receivers",
diff --git a/src/i18n/ru.json b/src/i18n/ru.json
index 2ffe9d0..a6dea84 100644
--- a/src/i18n/ru.json
+++ b/src/i18n/ru.json
@@ -87,7 +87,6 @@
     "DevTools": {
       "SearchButton": "Поиск",
       "SearchText": "Открыть контракт по адресу",
-      "DifferentContract": "Этот жеттон создан не с помощью этого вебсайта. Поэтому он может иметь иную логику и его данные могут неправильно отображаться на сайте.",
       "AdminAddress": "Адрес владельца",
       "TotalSupply": "Общее предложение",
       "Receivers": "Сообщения",
diff --git a/src/tonVerifier/consts.ts b/src/tonVerifier/consts.ts
new file mode 100644
index 0000000..249db8e
--- /dev/null
+++ b/src/tonVerifier/consts.ts
@@ -0,0 +1,14 @@
+import { Address } from "ton-core";
+
+/** TON Verifier mainnet registry contract address */
+export const ORBS_SOURCES_REGISTRY = Address.parse("EQD-BJSVUJviud_Qv7Ymfd3qzXdrmV525e3YDzWQoHIAiInL");
+/** TON Verifier testnet registry contract address */
+export const ORBS_SOURCES_REGISTRY_TESTNET = Address.parse("EQCsdKYwUaXkgJkz2l0ol6qT_WxeRbE_wBCwnEybmR0u5TO8");
+
+/** TON Orbs IPFS mainnet endpoint */
+export const ORBS_IPFS_ENDPOINT = "https://files.orbs.network/ipfs/"
+/** TON Orbs IPFS testnet endpoint */
+export const ORBS_IPFS_ENDPOINT_TESTNET = "https://tonsource-testnet.infura-ipfs.io/ipfs/";
+
+export const ORBS_REGISTRY_ID = "orbs.com";
+export const ORBS_REGISTRY_ID_TESTNET = "orbs-testnet";
diff --git a/src/tonVerifier/index.ts b/src/tonVerifier/index.ts
new file mode 100644
index 0000000..f07c153
--- /dev/null
+++ b/src/tonVerifier/index.ts
@@ -0,0 +1,123 @@
+import type { ContractABI, TonClient } from "ton";
+import { Address, Cell } from "ton-core";
+import { ORBS_IPFS_ENDPOINT, ORBS_IPFS_ENDPOINT_TESTNET, ORBS_REGISTRY_ID, ORBS_REGISTRY_ID_TESTNET, ORBS_SOURCES_REGISTRY, ORBS_SOURCES_REGISTRY_TESTNET } from "./consts";
+import { getStateInitByAddress } from "@/utils/tonHelpers";
+import { getSourceItemAddress, getSourceItemData } from "./registry";
+
+type MainNet = {
+  type: "mainnet"
+}
+type TestNet = {
+  type: "testnet"
+}
+type CustomNet = {
+  type: "custom",
+  registryId: string;
+  orbsSourcesRegistry: Address,
+  ipfsEndpoint: string
+}
+type AllowedNetworks = MainNet | TestNet | CustomNet;
+
+interface SourceItem {
+  url: string,
+  filename: string,
+}
+
+interface SourceResult {
+  sources: SourceItem[]
+}
+
+interface SourceFile {
+  code: string;
+  abi: string;
+}
+
+interface ContractVerifierOptions {
+  /**
+   * Blockchain network settings
+   */
+  network: AllowedNetworks;
+};
+
+export class ContractSourcesFetcher {
+  private registry: Address;
+  private registryId: string;
+  private ipfsEndpoint: string;
+  
+  constructor(opts: ContractVerifierOptions) {
+    switch (opts.network.type) {
+      case "mainnet":
+        this.registry = ORBS_SOURCES_REGISTRY;
+        this.registryId = ORBS_REGISTRY_ID;
+        this.ipfsEndpoint = ORBS_IPFS_ENDPOINT;
+        break;
+      case "testnet":
+        this.registry = ORBS_SOURCES_REGISTRY_TESTNET;
+        this.registryId = ORBS_REGISTRY_ID_TESTNET;
+        this.ipfsEndpoint = ORBS_IPFS_ENDPOINT_TESTNET;
+        break;
+      case "custom":
+        this.registry = opts.network.orbsSourcesRegistry;
+        this.registryId = opts.network.registryId;
+        this.ipfsEndpoint = opts.network.ipfsEndpoint;
+        break;
+    }
+  }
+
+  /**
+   * 
+   * @param tonClient TonClient instnace
+   * @param code 
+   * @returns 
+   */
+  public async getSource(tonClient: TonClient, code: Cell): Promise<ContractABI | null> {
+    const registryStateInit = await getStateInitByAddress(tonClient, this.registry);
+    if (!registryStateInit) {
+      return null;
+    }
+    const registryProvider = tonClient.provider(this.registry, registryStateInit);
+
+    const sourceItemAddress = await getSourceItemAddress(registryProvider, this.registryId, code);
+    const sourceItemStateInit = await getStateInitByAddress(tonClient, sourceItemAddress);
+    if (!sourceItemStateInit){
+      return null;
+    }
+    const sourceItemProvider = tonClient.provider(sourceItemAddress, sourceItemStateInit);
+
+    const sourcesUrl = await getSourceItemData(sourceItemProvider);
+    const sources = await this.fetchByIpfs<SourceResult>(sourcesUrl);
+
+    for (const sourceItem of sources.sources) {
+      if (sourceItem.filename.endsWith(".pkg")) {
+        const sourceFile = await this.fetchByIpfs<SourceFile>(sourceItem.url);
+        const sourceCodeCell = Cell.fromBase64(sourceFile.code);
+
+        if (sourceCodeCell.toBoc().toString("base64") == code.toBoc().toString("base64")) {
+          return JSON.parse(sourceFile.abi);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Convert ipfs url to http via ipfs http gateway
+   * @param ipfsLink ipfs url
+   * @returns http link
+   */
+  private replaceIpfsLink(ipfsLink: string): string {
+    return ipfsLink.replace("ipfs://", this.ipfsEndpoint)
+  }
+
+  /**
+   * Send request to IPFS url via http gateway and parses result to JSON
+   * @param ipfsLink ipfs url
+   * @returns JSON parsed result
+   */
+  private async fetchByIpfs<R>(ipfsLink: string): Promise<R> {
+    const url = this.replaceIpfsLink(ipfsLink);
+    const result = await fetch(url);
+    return await result.json();
+  }
+}
\ No newline at end of file
diff --git a/src/tonVerifier/registry.ts b/src/tonVerifier/registry.ts
new file mode 100644
index 0000000..230e3c0
--- /dev/null
+++ b/src/tonVerifier/registry.ts
@@ -0,0 +1,24 @@
+import { retry } from "@/utils/retry";
+import { bigIntFromBuffer } from "@/utils/tonHelpers";
+import type { Address, Cell, ContractProvider } from "ton-core";
+import { sha256 } from "ton-crypto";
+
+export async function getSourceItemAddress(provider: ContractProvider, registryId: string, code: Cell): Promise<Address> {
+  const result = await retry(async () => provider.get("get_source_item_address", [
+    {
+      type: "int",
+      value: bigIntFromBuffer(await sha256(registryId))
+    },
+    {
+      type: "int",
+      value: bigIntFromBuffer(code.hash())
+    },
+  ]));
+  return result.stack.readAddress()
+}
+
+export async function getSourceItemData(provider: ContractProvider): Promise<string> {
+  const result = await retry (() => provider.get("get_source_item_data", []));
+  const content = result.stack.skip(3).readCell().beginParse();
+  return content.loadStringTail();
+}
\ No newline at end of file
diff --git a/src/utils/devTools.ts b/src/utils/devTools.ts
new file mode 100644
index 0000000..da467c3
--- /dev/null
+++ b/src/utils/devTools.ts
@@ -0,0 +1,420 @@
+import AddressField from "@/components/Fields/AddressField.vue";
+import SliceField from "@/components/Fields/SliceField.vue";
+import { TonConnectUI } from "@tonconnect/ui";
+import { beginCell, type ABIField, type ABIGetter, type ABIReceiver, type ABIType, type Builder, type ContractProvider, type TupleItem } from "ton-core";
+import type { CreateComponentPublicInstanceWithMixins } from "vue";
+
+export interface BaseFieldInput {
+  optional: boolean,
+  label: string,
+  placeholder?: string
+  helpText?: string,
+}
+
+export type AnyFieldInput = { type: "any" };
+export type EmptyFieldInput = { type: "empty" };
+export type TextFieldInput = { type: "text" };
+export type CoinsFieldInput = { type: "uint", format: "coins" } & BaseFieldInput;
+export type UintFieldInput = { type: "uint", format: number } & BaseFieldInput;
+export type StringFieldInput = { type: "string" } & BaseFieldInput;
+export type SliceFieldInput = { type: "slice" } & BaseFieldInput;
+export type AddressFieldInput = { type: "address" } & BaseFieldInput;
+export type BoolFieldInput = { type: "bool" } & BaseFieldInput;
+export type UnknownFieldInput = { type: "unknown", expected: string } & BaseFieldInput;
+
+export type InputItem = AnyFieldInput
+  | EmptyFieldInput
+  | TextFieldInput
+  | CoinsFieldInput
+  | UintFieldInput
+  | StringFieldInput
+  | SliceFieldInput
+  | AddressFieldInput
+  | BoolFieldInput
+  | UnknownFieldInput;
+
+export interface SimpleFieldParameters {
+  name: string;
+  type: string;
+  optional: boolean;
+  format?: string | number | boolean;
+};
+
+export type BaseFieldElement = CreateComponentPublicInstanceWithMixins<{
+  validate(): boolean,
+  store(builder: Builder): void,
+}>;
+
+export class FieldsManager {
+  private fields: InputItem[];
+
+  constructor() {
+    this.fields = [];
+  }
+
+  /**
+   * List of fields
+   * @returns 
+   */
+  public getFields(): InputItem[] {
+    return this.fields;
+  }
+
+  /**
+   * Parse `receiver` field of Contract ABI and store its fields to class attributes
+   * @param receiver 
+   * @param types 
+   */
+  public storeReceiverFields(receiver: ABIReceiver, types: ABIType[]) {
+    switch (receiver.message.kind){
+      case "any":
+        this.storeAny();
+        return;
+      case "empty":
+        this.storeEmpty();
+        return;
+      case "text":
+        this.storeText();
+        return;
+      case "typed":
+        const type = this.findTypeByName(types, receiver.message.type);
+        if (!type) {
+          return;
+        }
+        this.storeTypes(type);
+    }
+  }
+
+  /**
+   * Parse `getter` field of contract ABI and store its fields to class attributes
+   * @param receiver 
+   * @param types 
+   */
+  public storeGetterFields(getter: ABIGetter, types: ABIType[]) {
+    if (!getter.arguments) {
+      return;
+    }
+
+    for (const field of getter.arguments) {
+      this.storeType(field);
+    }
+  }
+
+  /**
+   * Find contract type by its name
+   * @param types 
+   * @param typeName 
+   * @returns 
+   */
+  public findTypeByName(types: ABIType[], typeName: string): ABIType | undefined {
+    return types.find(t => t.name == typeName);
+  }
+
+  /**
+   * Store `any` field
+   */
+  public storeAny() {
+    this.fields.push({
+      type: "any",
+    });
+  }
+
+  /**
+   * Store `empty` field
+   */
+  public storeEmpty() {
+    this.fields.push({
+      type: "empty"
+    });
+  }
+
+  /**
+   * Store `text` field
+   */
+  public storeText() {
+    this.fields.push({
+      type: "text"
+    });
+  }
+
+  /**
+   * Store `dict` field
+   */
+  public storeDict() {
+    // TODO
+  }
+
+  /**
+   * Store `address` field
+   * @param type 
+   */
+  public storeAddress(type: SimpleFieldParameters) {
+    this.fields.push({
+      type: "address",
+      label: type.name,
+      optional: type.optional
+    });
+  }
+
+  /**
+   * Store `string` field
+   * @param type 
+   */
+  public storeString(type: SimpleFieldParameters) {
+    this.fields.push({
+      type: "string",
+      label: type.name,
+      optional: type.optional
+    });
+  }
+
+  /**
+   * Store `uint` field
+   * @param type 
+   * @returns 
+   */
+  public storeUint(type: SimpleFieldParameters) {
+    if (type.format == "coins") {
+      this.fields.push({
+        type: "uint",
+        format: "coins",
+        label: type.name,
+        optional: type.optional,
+      });
+    } else if (typeof type.format == "number") {
+      this.fields.push({
+        type: "uint",
+        format: type.format,
+        label: type.name,
+        optional: type.optional,
+      });
+    } else {
+      return this.storeUnknown(type.type + type.format)
+    }
+  }
+
+  /**
+   * Store `slice` field
+   * @param type 
+   */
+  public storeSlice(type: SimpleFieldParameters) {
+    this.fields.push({
+      type: "slice",
+      label: type.name,
+      optional: type.optional,
+    });
+  }
+
+  /**
+   * Store `unknown` field. For cases when class doesn't know how to handle specified type
+   * @param expected 
+   */
+  public storeUnknown(expected: string) {
+    // TODO
+    this.fields.push({
+      type: "unknown",
+      expected: expected,
+      label: "Unknown field",
+      optional: false,
+    })
+  }
+
+  /**
+   * Store `simple` typed field
+   * @param type 
+   * @returns 
+   */
+  public storeSimple(type: SimpleFieldParameters) {
+    switch (type.type) {
+      case "address":
+        return this.storeAddress(type);
+      case "string":
+        return this.storeString(type);
+      case "uint":
+        return this.storeUint(type);
+      case "int":
+        return this.storeUnknown(type.type); // TODO
+      case "bool":
+        return this.storeUnknown(type.type); // TODO
+      case "cell":
+        return this.storeUnknown(type.type); // TODO
+      case "slice":
+        return this.storeSlice(type);
+      default:
+        return this.storeUnknown(type.type);
+    }
+  }
+
+  /**
+   * Store single field
+   * @param field 
+   */
+  public storeType(field: ABIField) {
+    switch (field.type.kind) {
+        case "dict":
+          this.storeDict()
+          break;
+        case "simple":
+          this.storeSimple({
+            name: field.name,
+            type: field.type.type,
+            optional: field.type.optional ?? true,
+            format: field.type.format ?? undefined
+          });
+          break;
+      }
+  }
+
+  /**
+   * Store field array
+   * @param type 
+   */
+  public storeTypes(type: ABIType) {
+    for (const field of type.fields) {
+      this.storeType(field)
+    }
+  }
+}
+
+/**
+ * Base extractor/parser class for contract ABI
+ */
+export class BaseDevTools {
+  protected fields: FieldsManager;
+  protected title?: string;
+  protected elements: BaseFieldElement[];
+
+  constructor() {
+    this.fields = new FieldsManager();
+    this.elements = [];
+  }
+
+  /**
+   * List of fields
+   * @returns 
+   */
+  public getFields(): InputItem[] {
+    return this.fields.getFields();
+  }
+
+  public registerInput(el: BaseFieldElement) {
+    console.log("NEW INPUT", this.elements.length, el);
+    this.elements.push(el);
+  }
+
+  public getTitle(): string | null{
+    return this.title ?? null;
+  }
+
+  public async execute(): Promise<boolean> {
+    let success = true;
+    for (const el of this.elements) {
+      success &&= el.validate();
+    }
+    return success;
+  }
+}
+
+interface ReceiverDevToolsOptions {
+  receiver: ABIReceiver;
+  types: ABIType[];
+  tonConnectUI: TonConnectUI;
+  address: string;
+  tonAmount: bigint;
+}
+
+export class ReceiverDevTools extends BaseDevTools {
+  private header?: number;
+  private address: string;
+  private tonConnectUI: TonConnectUI;
+  private tonAmount: bigint;
+
+  constructor(options: ReceiverDevToolsOptions) {
+    super();
+
+    this.tonConnectUI = options.tonConnectUI;
+    this.address = options.address;
+    this.tonAmount = options.tonAmount;
+
+    if (options.receiver.message.kind == "typed") {
+      const type = this.fields.findTypeByName(options.types, options.receiver.message.type);
+      if (type) {
+        this.header = type.header ?? undefined;
+        this.title = type.name;
+      }
+    }
+
+    this.fields.storeReceiverFields(options.receiver, options.types);
+  }
+
+  public override async execute(): Promise<boolean> {
+    if (!await super.execute()) {
+      return false;
+    }
+
+    const tx = beginCell();
+
+    if (this.header) {
+      tx.storeUint(this.header, 32);
+    }
+
+    for (const el of this.elements) {
+      tx.store(el.store);
+    }
+
+    await this.tonConnectUI.sendTransaction(
+      {
+        validUntil: Math.floor(Date.now() / 1000) + 360,
+        messages: [
+          {
+            address: this.address,
+            amount: this.tonAmount.toString(),
+            payload: tx.endCell().toBoc().toString("base64"),
+          }
+        ]
+      }
+    );
+
+    return true;
+  }
+}
+
+interface GetterDevToolsOptions {
+  getter: ABIGetter;
+  types: ABIType[];
+  provider: ContractProvider;
+}
+
+export class GetterDevTools extends BaseDevTools {
+  private name: string;
+  private provider: ContractProvider;
+
+  constructor(options: GetterDevToolsOptions) {
+    super();
+
+    this.provider = options.provider;
+
+    this.name = options.getter.name;
+    this.title = options.getter.name;
+
+    this.fields.storeGetterFields(options.getter, options.types);
+  }
+
+  public override async execute(): Promise<boolean> {
+    if (!await super.execute()) {
+      return false;
+    }
+
+    const args = [] as TupleItem[];
+    for (const el of this.elements) {
+      args.push({
+        type: "slice",
+        cell: beginCell().store(el.store).endCell()
+      })
+    }
+
+    const result = await this.provider.get(this.name, args);
+
+    return true;
+  }
+}
diff --git a/src/utils/retry.ts b/src/utils/retry.ts
new file mode 100644
index 0000000..10c4d33
--- /dev/null
+++ b/src/utils/retry.ts
@@ -0,0 +1,17 @@
+
+/**
+ * Call `fn` function `retryCount` times until success
+ * @param fn function that will be called `retryCount` times until success (at least 1 time)
+ * @param retryCount retries count
+ * @returns function result
+ */
+export async function retry<R>(fn: () => R, retryCount: number = 10): Promise<R> {
+  for (let i = 0; i < retryCount - 1; i++) {
+    try {
+      return await fn();
+    } catch {
+      continue
+    }
+  }
+  return fn();
+}
diff --git a/src/utils/tonHelpers.ts b/src/utils/tonHelpers.ts
new file mode 100644
index 0000000..55f9e73
--- /dev/null
+++ b/src/utils/tonHelpers.ts
@@ -0,0 +1,48 @@
+import type { TonClient } from "ton";
+import { Address, Cell } from "ton-core";
+import { retry } from "./retry";
+
+/**
+ * Convert Buffer to BigInt
+ * @param buffer Buffer which will be converted to BigInt
+ * @returns bigint
+ */
+export function bigIntFromBuffer(buffer: Buffer): bigint {
+  return BigInt(`0x${buffer.toString("hex")}`);
+}
+
+/**
+ * Alias to `Address.parse` with error mapping
+ * @param {string} address TON contract address in any format
+ * @returns {Address | null} null if address is invalid, otherwise parsed Address
+ */
+export function parseAddress(address: string): Address | null {
+  try {
+    return Address.parse(address)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Alias to `tonClient.getContractState` with checking if account is exists
+ * @param tonClient TonClient instance
+ * @param address TON Address
+ * @returns StateInit if everythink Ok, otherwise null
+ */
+export async function getStateInitByAddress(tonClient: TonClient, address: Address): Promise<{ code: Cell, data: Cell} | null> {
+  try {
+    const contractState = await retry(() => tonClient.getContractState(address));
+
+    if (contractState.state == "uninitialized") {
+      return null
+    }
+
+    const code = Cell.fromBase64(contractState.code?.toString("base64") as string);
+    const data = Cell.fromBase64(contractState.data?.toString("base64") as string);
+
+    return { code, data };
+  } catch {
+    return null;
+  }
+}
diff --git a/src/views/DevTools.vue b/src/views/DevTools.vue
index 57888e4..1b07529 100644
--- a/src/views/DevTools.vue
+++ b/src/views/DevTools.vue
@@ -5,24 +5,18 @@
   <div v-else
     class="fixed-grid has-1-cols-mobile has-1-cols-tablet has-4-cols-desktop has-4-cols-widescreen has-4-cols-fullhd">
     <div class="grid is-gap-1">
-      <div v-if="!isCorrectInterface" class="cell is-col-span-4-desktop">
+      <div v-for="warning in warnings" v-bind:key="warning" class="cell is-col-span-4-desktop">
         <div class="box is-shadowless has-background-warning-light">
           <span class="tag is-warning">{{ $t('message.Common.Warning') }}</span>
-          {{ $t('message.DevTools.DifferentContract') }}
+          {{ warning }}
         </div>
       </div>
-      <div v-if="!isSourceCodeProvided" class="cell is-col-span-4-desktop">
-        <div class="box is-shadowless has-background-warning-light">
-          <span class="tag is-warning">{{ $t('message.Common.Warning') }}</span>
-          {{ $t('message.DevTools.NoSourceCode') }}
-        </div>
-      </div>
-      <div v-if="jettonData && parsedMetadata" class="cell is-col-span-4-desktop">
+      <!-- <div v-if="jettonData && parsedMetadata" class="cell is-col-span-4-desktop">
         <div class="box is-shadowless has-background-light">
           <JettonCardBig :is-correct-interface="isCorrectInterface" :jetton-data="jettonData"
             :parsed-metadata="parsedMetadata" />
         </div>
-      </div>
+      </div> -->
       <div class="cell is-col-span-1-desktop">
         <div class="box is-shadowless has-background-light">
           <aside class="menu">
@@ -71,124 +65,13 @@
 
 <script lang="ts">
 import JettonCardBig from '@/components/DevTools/JettonCardBig.vue';
-import { parseMetadata } from '@/utils/dict';
-import { SupaDupaJettonMaster } from '@/utils/jettonMaster';
-import type { JettonMasterData, MetadataDict } from '@/utils/types';
-import type { ContractABI, ContractProvider, TonClient } from 'ton';
-import { Address, Cell } from 'ton-core';
-import jettonMasterABI from "@/assets/JettonMaster.abi.json";
+import { type ContractABI } from 'ton';
 import ContractOperationsItemGetter from '@/components/DevTools/ContractOperationsItemGetter.vue';
 import ContractOperationsItemReceiver from '@/components/DevTools/ContractOperationsItemReceiver.vue';
 import ContractManageForm from '@/components/DevTools/ContractManageForm.vue';
-
-// const ORBS_SOURCES_REGISTRY = Address.parse("EQD-BJSVUJviud_Qv7Ymfd3qzXdrmV525e3YDzWQoHIAiInL");
-const ORBS_SOURCES_REGISTRY_TESTNET = Address.parse("EQCsdKYwUaXkgJkz2l0ol6qT_WxeRbE_wBCwnEybmR0u5TO8");
-// const ORBS_IPFS_ENDPOINT = "https://files.orbs.network/ipfs/"
-const ORBS_IPFS_ENDPOINT_TESTNET = "https://tonsource-testnet.infura-ipfs.io/ipfs/";
-
-interface SourceItem {
-  url: string,
-  filename: string,
-}
-
-interface SourceResult {
-  sources: SourceItem[]
-}
-
-function bigIntFromBuffer(buffer: Buffer): bigint {
-  return BigInt(`0x${buffer.toString("hex")}`);
-}
-
-async function getSources(codeCell: Cell, tonClient: TonClient) {
-  let abi = null
-  // Source provider
-  const contractState = await tonClient.getContractState(ORBS_SOURCES_REGISTRY_TESTNET); // TODO add error handling
-  const code = Cell.fromBase64(contractState.code?.toString("base64") as string);
-  const data = Cell.fromBase64(contractState.data?.toString("base64") as string);
-  const provider = tonClient.provider(ORBS_SOURCES_REGISTRY_TESTNET, { code, data });
-  const result = await provider.get("get_source_item_address", [
-    // {
-    //   type: "int",
-    //   value: bigIntFromBuffer(await sha256("orbs.com"))
-    // },
-    { // TODO ?
-      type: "int",
-      value: 17676787183715497356968962353312138049121632594906749996652211766711021743417n
-    },
-    {
-      type: "int",
-      value: bigIntFromBuffer(codeCell.hash())
-    },
-  ]);
-
-  // Source contract
-  const address = result.stack.readAddress();
-  const sourceContractState = await tonClient.getContractState(address); // TODO add error handling
-  if (!sourceContractState.code) {
-    return null;
-  }
-  const sourceCode = Cell.fromBase64(sourceContractState.code?.toString("base64") as string);
-  const sourceData = Cell.fromBase64(sourceContractState.data?.toString("base64") as string);
-  const sourceProvider = tonClient.provider(address, { code: sourceCode, data: sourceData });
-  const sourceResult = await sourceProvider.get("get_source_item_data", []);
-  const contentCell = sourceResult.stack.skip(3).readCell().beginParse();
-  const ipfsLink = contentCell.loadStringTail();
-
-  const verifiedContract = await (await fetch(ipfsLink.replace("ipfs://", ORBS_IPFS_ENDPOINT_TESTNET))).json() as SourceResult;
-  for (const source of verifiedContract.sources) {
-    if (source.filename.endsWith(".pkg")) {
-      const url = source.url.replace("ipfs://", ORBS_IPFS_ENDPOINT_TESTNET);
-      const content = await fetch(url).then((u) => u.json());
-      const pkgCodeCell = Cell.fromBase64(content.code).toBoc().toString("base64");
-      if (pkgCodeCell == codeCell.toBoc().toString("base64")) {
-        abi = JSON.parse(content.abi);
-      }
-    }
-  }
-
-  return abi;
-}
-
-async function initJettonMetadata(tonClient: TonClient, address: Address) {
-  let isCorrectInterface = true;
-
-  // Getting contract state
-  const contractState = await tonClient.getContractState(address); // TODO add error handling
-
-  if (contractState.state == "uninitialized") {
-    return null
-  }
-
-  // Getting toncenter provider
-  const code = Cell.fromBase64(contractState.code?.toString("base64") as string);
-  const data = Cell.fromBase64(contractState.data?.toString("base64") as string);
-  const provider = tonClient.provider(address, { code, data });
-
-  let jettonData = null;
-  let parsedMetadata = null
-  try {
-    // Open jetton master contract
-    const jettonMaster = new SupaDupaJettonMaster(address);
-    const contract = tonClient.open(jettonMaster);
-
-    // Execute jetton supported_interfaces getter
-    const interfaces = await contract.supportedInterfaces(provider);
-    isCorrectInterface = interfaces.includes(0xc26445264d7dbe48b97b619da755d205n);
-
-    jettonData = await contract.jettonData(provider);
-    parsedMetadata = await parseMetadata(jettonData.content);
-  } catch {
-    isCorrectInterface = false;
-  }
-
-  return {
-    isCorrectInterface,
-    parsedMetadata,
-    jettonData,
-    provider,
-    abi: await getSources(code, tonClient)
-  }
-}
+import { getStateInitByAddress, parseAddress } from '@/utils/tonHelpers';
+import { ContractSourcesFetcher } from '@/tonVerifier';
+import DefaultABI from "@/assets/JettonMaster.abi.json";
 
 export default {
   components: {
@@ -198,30 +81,34 @@ export default {
     return {
       abi: {} as ContractABI,
       loading: true,
-      jettonData: null as JettonMasterData | null,
-      parsedMetadata: null as MetadataDict | null,
-      isCorrectInterface: true,
-      isSourceCodeProvided: true,
-      provider: {} as ContractProvider,
+      warnings: [] as string[]
     }
   },
   async created() {
-    const address = Address.parse(this.$route.params.address as string);
+    const address = parseAddress(this.$route.params.address as string)
+    if (!address) {
+      // TODO 404
+      return;
+    }
+
+    const stateInit = await getStateInitByAddress(this.$tonClient, address);
+    if (!stateInit) {
+      // TODO 404
+      return;
+    }
+    const provider = this.$tonClient.provider(address, stateInit);
 
-    // Parse jetton metadata
-    const result = await initJettonMetadata(this.$tonClient, address)
-    if (result) {
-      const { isCorrectInterface, jettonData, parsedMetadata, provider, abi } = result;
-      this.isCorrectInterface = isCorrectInterface;
-      this.jettonData = jettonData;
-      this.parsedMetadata = parsedMetadata;
-      this.provider = provider;
-      if (abi) {
-        this.abi = abi as ContractABI;
-      } else {
-        this.isSourceCodeProvided = false;
-        this.abi = jettonMasterABI as ContractABI;
+    const sourceFetcher = new ContractSourcesFetcher({
+      network: {
+        type: "testnet"
       }
+    });
+    const abi = await sourceFetcher.getSource(this.$tonClient, stateInit.code);
+    if (abi) {
+      this.abi = abi;
+    } else {
+      this.warnings.push(this.$t("message.DevTools.NoSourceCode"));
+      this.abi = DefaultABI as ContractABI;
     }
 
     this.loading = false;