From ad0110edf0c7e9da202f63d3bef698cc56dbc8b6 Mon Sep 17 00:00:00 2001
From: Rahul Yadav <rahulkyadav57@gmail.com>
Date: Sat, 4 Nov 2023 06:54:07 +0530
Subject: [PATCH] Create custom field for data type

---
 .../DashboardSidebar/DashboardSidebar.tsx     |   4 +-
 .../project/NewProject/NewProject.tsx         |   5 +-
 src/components/workspace/ABIUi/ABIUi.tsx      |  83 +++--
 .../BuildProject/BuildProject.module.scss     |   2 +-
 .../workspace/BuildProject/BuildProject.tsx   | 114 +++++-
 .../workspace/WorkSpace/WorkSpace.tsx         |   2 +-
 .../workspace/abiInputs/Address.tsx           |  40 +++
 src/components/workspace/abiInputs/Amount.tsx |  37 ++
 src/components/workspace/abiInputs/Bool.tsx   |  35 ++
 src/components/workspace/abiInputs/Buffer.tsx |  42 +++
 src/components/workspace/abiInputs/Cell.tsx   |  43 +++
 src/components/workspace/abiInputs/Null.tsx   |  42 +++
 src/components/workspace/abiInputs/String.tsx |  34 ++
 src/components/workspace/abiInputs/index.ts   |   7 +
 src/hooks/contract.hooks.ts                   | 333 ++++++++++++++----
 src/hooks/project.hooks.ts                    |  16 +-
 src/pages/_app.tsx                            |   2 +-
 src/utility/utils.ts                          |  50 +++
 tsconfig.json                                 |   2 +-
 19 files changed, 774 insertions(+), 119 deletions(-)
 create mode 100644 src/components/workspace/abiInputs/Address.tsx
 create mode 100644 src/components/workspace/abiInputs/Amount.tsx
 create mode 100644 src/components/workspace/abiInputs/Bool.tsx
 create mode 100644 src/components/workspace/abiInputs/Buffer.tsx
 create mode 100644 src/components/workspace/abiInputs/Cell.tsx
 create mode 100644 src/components/workspace/abiInputs/Null.tsx
 create mode 100644 src/components/workspace/abiInputs/String.tsx
 create mode 100644 src/components/workspace/abiInputs/index.ts

diff --git a/src/components/dashboard/DashboardSidebar/DashboardSidebar.tsx b/src/components/dashboard/DashboardSidebar/DashboardSidebar.tsx
index e4c1560..3452451 100644
--- a/src/components/dashboard/DashboardSidebar/DashboardSidebar.tsx
+++ b/src/components/dashboard/DashboardSidebar/DashboardSidebar.tsx
@@ -19,13 +19,13 @@ const DashboardSidebar: FC<Props> = ({ className }) => {
       <div className={s.menuItems}>
         <div>
           <span className={`${s.name} ${s.item}`}>Welcome 👋</span>
-          <span
+          {/* <span
             className={`${s.name} ${s.item}`}
             onClick={() => startOnboarding(0)}
           >
             <AppIcon name="Play" />
             Start help wizard
-          </span>
+          </span> */}
           <Link
             className={`${s.name} ${s.item}`}
             href="https://docs.nujan.io/"
diff --git a/src/components/project/NewProject/NewProject.tsx b/src/components/project/NewProject/NewProject.tsx
index a6f7296..b5bfa87 100644
--- a/src/components/project/NewProject/NewProject.tsx
+++ b/src/components/project/NewProject/NewProject.tsx
@@ -30,9 +30,12 @@ const NewProject: FC = () => {
   ];
 
   const templatedList = [
-    { label: 'Blank Contract', value: 'tonBlank' },
+    // { label: 'Blank Contract', value: 'tonBlank' },
     { label: 'Counter Contract', value: 'tonCounter' },
+    { label: 'NFT Contract', value: 'nft', lang: 'tact' },
+
     { label: 'Import Contract', value: 'import' },
+
     // { label: 'Chat Bot Contract', value: 'chatBot' },
   ];
 
diff --git a/src/components/workspace/ABIUi/ABIUi.tsx b/src/components/workspace/ABIUi/ABIUi.tsx
index 28fbadd..e13414a 100644
--- a/src/components/workspace/ABIUi/ABIUi.tsx
+++ b/src/components/workspace/ABIUi/ABIUi.tsx
@@ -32,7 +32,10 @@ const ABIUi: FC<Props> = ({
     if (['cell', 'slice'].includes(item.type)) {
       return [item.type, 'address'];
     }
-    return [item.type];
+    if (typeof item.type === 'string') {
+      return [item.type];
+    }
+    return [(item.type as any).type];
   });
 
   const [isLoading, setIsLoading] = useState(false);
@@ -56,7 +59,7 @@ const ABIUi: FC<Props> = ({
 
       const callableFunction = type === 'Getter' ? callGetter : callSetter;
 
-      const getterReponse = await callableFunction(
+      const response = await callableFunction(
         contractAddress,
         abi.name,
         contract as any,
@@ -66,8 +69,12 @@ const ABIUi: FC<Props> = ({
         network
       );
 
-      if (getterReponse) {
-        createLog(JSON.stringify(getterReponse));
+      if (response?.logs) {
+        for (const log of response?.logs) {
+          createLog(log);
+        }
+      } else {
+        createLog(JSON.stringify(response));
       }
     } catch (error: any) {
       console.log('error', error);
@@ -90,30 +97,50 @@ const ABIUi: FC<Props> = ({
   return (
     <div className={s.root}>
       <Form className={s.form} onFinish={onSubmit}>
-        {abi.parameters.map((item: ABIParameter, i: number) => (
-          <div key={i}>
-            <Form.Item
-              name={[i, item.name, 'type']}
-              className={`${s.formItemABI} ${s.formItemType}}`}
-              rules={[{ required: true, message: 'Please select type' }]}
-            >
-              <Select placeholder="select type">
-                {possiblesTypes[i].map((type, _j) => (
-                  <Option key={`${i}-${_j}`} value={type}>
-                    {type}
-                  </Option>
-                ))}
-              </Select>
-            </Form.Item>
-            <Form.Item
-              name={[i, item.name, 'value']}
-              className={s.formItemABI}
-              rules={[{ required: true, message: 'Please input value' }]}
-            >
-              <Input placeholder={`${item.name}: ${item.type}`} />
-            </Form.Item>
-          </div>
-        ))}
+        {abi.parameters.map((item: ABIParameter, i: number) => {
+          if (item.name === 'queryId') {
+            return (
+              <Form.Item
+                key={i}
+                name={[i, item.name, 'type']}
+                className={`${s.formItemABI} ${s.formItemType}}`}
+                rules={[{ required: true, message: 'Please select type' }]}
+              >
+                <Input type="hidden" value={0} />
+              </Form.Item>
+            );
+          }
+          return (
+            <div key={i}>
+              <Form.Item
+                name={[i, item.name, 'type']}
+                className={`${s.formItemABI} ${s.formItemType}}`}
+                rules={[{ required: true, message: 'Please select type' }]}
+              >
+                <Select placeholder="select type">
+                  {possiblesTypes[i].map((type, _j) => (
+                    <Option key={`${i}-${_j}`} value={type}>
+                      {type}
+                    </Option>
+                  ))}
+                </Select>
+              </Form.Item>
+              <Form.Item
+                name={[i, item.name, 'value']}
+                className={s.formItemABI}
+                rules={[{ required: true, message: 'Please input value' }]}
+              >
+                <Input
+                  placeholder={`${item.name}: ${
+                    typeof item.type === 'string'
+                      ? item.type
+                      : (item.type as any).type
+                  }`}
+                />
+              </Form.Item>
+            </div>
+          );
+        })}
 
         <Button
           className={s.btnAction}
diff --git a/src/components/workspace/BuildProject/BuildProject.module.scss b/src/components/workspace/BuildProject/BuildProject.module.scss
index e83e15e..58dbe3f 100644
--- a/src/components/workspace/BuildProject/BuildProject.module.scss
+++ b/src/components/workspace/BuildProject/BuildProject.module.scss
@@ -2,7 +2,7 @@
   padding: 1rem;
   width: 100%;
   height: 100vh;
-  // overflow-y: auto;
+  overflow-y: auto;
   .heading {
     opacity: 0.6;
     margin-bottom: 0.5rem;
diff --git a/src/components/workspace/BuildProject/BuildProject.tsx b/src/components/workspace/BuildProject/BuildProject.tsx
index 26735a3..f028880 100644
--- a/src/components/workspace/BuildProject/BuildProject.tsx
+++ b/src/components/workspace/BuildProject/BuildProject.tsx
@@ -9,17 +9,57 @@ import { getContractLINK } from '@/utility/utils';
 import { Network } from '@orbs-network/ton-access';
 import { Blockchain } from '@ton-community/sandbox';
 import { CHAIN, useTonConnectUI } from '@tonconnect/ui-react';
-import { Button, Form, Input, Select } from 'antd';
+import { Button, Form, Select } from 'antd';
 import Link from 'next/link';
 import { FC, useEffect, useRef, useState } from 'react';
-import { Cell } from 'ton-core';
+import { Address, Cell } from 'ton-core';
 import ContractInteraction from '../ContractInteraction';
 import ExecuteFile from '../ExecuteFile/ExecuteFile';
 import OpenFile from '../OpenFile/OpenFile';
 import s from './BuildProject.module.scss';
 
+import {
+  AddressInput,
+  AmountInput,
+  BoolInput,
+  BufferInput,
+  CellInput,
+  NullInput,
+  StringInput,
+} from '../abiInputs';
 import { globalWorkspace } from '../globalWorkspace';
 
+const fields = (type: String) => {
+  if (
+    type.includes('int') ||
+    type == 'Int' ||
+    type == 'bigint | number' ||
+    type == 'number | bigint'
+  )
+    return AmountInput;
+  switch (type) {
+    case 'Address':
+      return AddressInput;
+    case 'Bool':
+      return BoolInput;
+    case 'Buffer':
+      return BufferInput;
+    case 'bigint':
+    case 'number':
+      return AmountInput;
+    case 'string':
+      return StringInput;
+    case 'Cell':
+    case 'Builder':
+    case 'Slice':
+      return CellInput;
+    case 'null':
+      return NullInput;
+    default:
+      return StringInput;
+  }
+};
+
 interface Props {
   projectId: string;
   onCodeCompile: (codeBOC: string) => void;
@@ -75,20 +115,21 @@ const BuildProject: FC<Props> = ({
         <Form className={s.form} onFinish={initDeploy}>
           {activeProject?.initParams && (
             <div>
-              {activeProject?.initParams?.map((item, index) => (
-                <Form.Item
-                  className={s.formItem}
-                  key={index}
-                  name={item.name}
-                  rules={[{ required: !item.optional }]}
-                >
-                  <Input
+              {activeProject?.initParams?.map((item, index) => {
+                if (item.name === 'queryId') return <></>;
+                const Field = fields(item.type);
+                return (
+                  <Field
+                    key={index}
+                    className={s.formItem}
+                    name={item.name}
                     placeholder={`${item.name}: ${item.type}${
                       item.optional ? '?' : ''
                     }`}
+                    rules={[{ required: !item.optional }]}
                   />
-                </Form.Item>
-              ))}
+                );
+              })}
             </div>
           )}
           <Button
@@ -111,11 +152,41 @@ const BuildProject: FC<Props> = ({
     if (_temp.queryId) {
       delete _temp.queryId;
     }
+    const initParamsData = activeProject?.initParams;
+    let parametrsType: any = {};
+    if (initParamsData) {
+      parametrsType = initParamsData.reduce(
+        (acc: any, curr) => ((acc[curr.name] = curr.type), acc),
+        {}
+      );
+    }
 
     for (const [key, value] of Object.entries(_temp)) {
-      if (value) {
+      const type = parametrsType[key];
+      console.log(key, value);
+      if (
+        type.includes('int') ||
+        type == 'Int' ||
+        type == 'bigint | number' ||
+        type == 'number | bigint'
+      ) {
         initParams += `BigInt(${value}),`;
+        continue;
       }
+      // if (value) {
+      switch (type) {
+        case 'Address':
+          initParams += eval(
+            `(Address) => { return Address.parse(${value}"; }`
+          )(Address);
+          continue;
+        case 'Bool':
+          initParams += `${!!value},`;
+          continue;
+      }
+      if (parametrsType[key] == 'Address') {
+      }
+      // }
     }
     initParams = initParams.slice(0, -1);
 
@@ -140,10 +211,7 @@ const BuildProject: FC<Props> = ({
   };
 
   const deploy = async () => {
-    createLog(
-      `Deploying contract with code BOC -  ${activeProject?.contractBOC}`,
-      'info'
-    );
+    createLog(`Deploying contract ...`, 'info');
     try {
       if (sandboxBlockchain && environment === 'SANDBOX') {
         const blockchain = await Blockchain.create();
@@ -157,7 +225,11 @@ const BuildProject: FC<Props> = ({
           false
         );
       }
-      const { address: _contractAddress, contract } = await deployContract(
+      const {
+        address: _contractAddress,
+        contract,
+        logs,
+      } = await deployContract(
         activeProject?.contractBOC as string,
         buildOutput?.dataCell as any,
         environment.toLowerCase() as Network,
@@ -176,6 +248,12 @@ const BuildProject: FC<Props> = ({
         )}`,
         'success'
       );
+
+      for (let i = 0; i < (logs || []).length; i++) {
+        if (!logs?.[i]) continue;
+        createLog(logs[i], 'info', false);
+      }
+
       if (!_contractAddress) {
         return;
       }
diff --git a/src/components/workspace/WorkSpace/WorkSpace.tsx b/src/components/workspace/WorkSpace/WorkSpace.tsx
index 957b9af..574db3d 100644
--- a/src/components/workspace/WorkSpace/WorkSpace.tsx
+++ b/src/components/workspace/WorkSpace/WorkSpace.tsx
@@ -65,7 +65,7 @@ const WorkSpace: FC = () => {
     console.log = (...args) => {
       originalConsoleLog(...args); // Call the original console.log
       const _log = args.join(' ');
-      if (!_log.includes('DEBUG')) {
+      if (!_log.includes('DEBUG') || activeProject?.language === 'tact') {
         return;
       }
       const splittedLog = _log.split('\n');
diff --git a/src/components/workspace/abiInputs/Address.tsx b/src/components/workspace/abiInputs/Address.tsx
new file mode 100644
index 0000000..b0efe51
--- /dev/null
+++ b/src/components/workspace/abiInputs/Address.tsx
@@ -0,0 +1,40 @@
+import { Form, Input } from 'antd';
+import { Rule, RuleObject } from 'antd/es/form';
+import { Address } from 'ton-core';
+
+interface Props {
+  name?: string;
+  placeholder?: string;
+  className?: string;
+  rules?: Rule[];
+}
+
+const AddressInput = ({
+  name = 'address',
+  placeholder = 'EQDPK...0nYxC',
+  className = '',
+  rules = [],
+}: Props) => {
+  const fieldRules = [
+    ...rules,
+    () => ({
+      validator(_rule: RuleObject, value: string) {
+        if (!value) return Promise.resolve();
+        try {
+          Address.parse(value);
+        } catch {
+          return Promise.reject('Invalid Address');
+        }
+
+        return Promise.resolve();
+      },
+    }),
+  ];
+  return (
+    <Form.Item name={name} rules={fieldRules} className={className}>
+      <Input placeholder={placeholder} />
+    </Form.Item>
+  );
+};
+
+export default AddressInput;
diff --git a/src/components/workspace/abiInputs/Amount.tsx b/src/components/workspace/abiInputs/Amount.tsx
new file mode 100644
index 0000000..6f6dba4
--- /dev/null
+++ b/src/components/workspace/abiInputs/Amount.tsx
@@ -0,0 +1,37 @@
+import { Form, Input } from 'antd';
+import { RuleObject } from 'antd/es/form';
+
+interface Props {
+  name?: string;
+  placeholder?: string;
+  className?: string;
+}
+
+const AmountInput = ({
+  name = 'amount',
+  placeholder = '123',
+  className = '',
+}: Props) => {
+  const rules = [
+    { required: true },
+    () => ({
+      validator(_rule: RuleObject, value: string) {
+        if (!value) return Promise.resolve();
+        const pattern = /^[0-9]+(\.[0-9]+)?$/;
+        const result = pattern.test(value);
+        if (!result) {
+          return Promise.reject('Invalid Number');
+        }
+
+        return Promise.resolve();
+      },
+    }),
+  ];
+  return (
+    <Form.Item name={name} rules={rules} className={className}>
+      <Input placeholder={placeholder} />
+    </Form.Item>
+  );
+};
+
+export default AmountInput;
diff --git a/src/components/workspace/abiInputs/Bool.tsx b/src/components/workspace/abiInputs/Bool.tsx
new file mode 100644
index 0000000..3fe4c44
--- /dev/null
+++ b/src/components/workspace/abiInputs/Bool.tsx
@@ -0,0 +1,35 @@
+import { Form, Switch } from 'antd';
+import { RuleObject } from 'antd/es/form';
+
+interface Props {
+  name?: string;
+  placeholder: string;
+  className?: string;
+}
+
+const BoolInput = ({ name = 'b', placeholder, className = '' }: Props) => {
+  const rules = [
+    // { required: true },
+    () => ({
+      validator(_rule: RuleObject, value: string) {
+        console.log('value', value);
+        if (typeof !!value !== 'boolean')
+          return Promise.reject('Not a boolean');
+        return Promise.resolve();
+      },
+    }),
+  ];
+  return (
+    <Form.Item
+      name={name}
+      label={placeholder.split(':')[0]}
+      rules={rules}
+      className={className}
+      valuePropName="checked"
+    >
+      <Switch />
+    </Form.Item>
+  );
+};
+
+export default BoolInput;
diff --git a/src/components/workspace/abiInputs/Buffer.tsx b/src/components/workspace/abiInputs/Buffer.tsx
new file mode 100644
index 0000000..e9c658f
--- /dev/null
+++ b/src/components/workspace/abiInputs/Buffer.tsx
@@ -0,0 +1,42 @@
+import { Form, Input } from 'antd';
+import { RuleObject } from 'antd/es/form';
+
+interface Props {
+  name?: string;
+  placeholder?: string;
+  className?: string;
+}
+
+const BufferInput = ({
+  name = 'buffer',
+  placeholder = 'HEX or base64 bytes',
+  className = '',
+}: Props) => {
+  const rules = [
+    { required: true },
+    () => ({
+      validator(_rule: RuleObject, value: string) {
+        if (!value) return Promise.resolve();
+        // first try to parse as hex. if fails, try to parse as base64
+        try {
+          Buffer.from(value, 'hex');
+        } catch {
+          try {
+            Buffer.from(value, 'base64');
+          } catch {
+            return Promise.reject('Invalid Buffer');
+          }
+        }
+
+        return Promise.resolve();
+      },
+    }),
+  ];
+  return (
+    <Form.Item name={name} rules={rules} className={className}>
+      <Input placeholder={placeholder} />
+    </Form.Item>
+  );
+};
+
+export default BufferInput;
diff --git a/src/components/workspace/abiInputs/Cell.tsx b/src/components/workspace/abiInputs/Cell.tsx
new file mode 100644
index 0000000..998272d
--- /dev/null
+++ b/src/components/workspace/abiInputs/Cell.tsx
@@ -0,0 +1,43 @@
+import { Form, Input } from 'antd';
+import { RuleObject } from 'antd/es/form';
+import { Cell } from 'ton-core';
+
+interface Props {
+  name?: string;
+  placeholder?: string;
+  className?: string;
+}
+
+const CellInput = ({
+  name = 'buffer',
+  placeholder = 'HEX or base64 serialized cell',
+  className = '',
+}: Props) => {
+  const rules = [
+    { required: true },
+    () => ({
+      validator(_rule: RuleObject, value: string) {
+        if (!value) return Promise.resolve();
+        // first try to parse as hex. if fails, try to parse as base64
+        try {
+          Cell.fromBoc(Buffer.from(value, 'hex'))[0];
+        } catch {
+          try {
+            Cell.fromBase64(value);
+          } catch {
+            return Promise.reject('Invalid');
+          }
+        }
+
+        return Promise.resolve();
+      },
+    }),
+  ];
+  return (
+    <Form.Item name={name} rules={rules} className={className}>
+      <Input placeholder={placeholder} />
+    </Form.Item>
+  );
+};
+
+export default CellInput;
diff --git a/src/components/workspace/abiInputs/Null.tsx b/src/components/workspace/abiInputs/Null.tsx
new file mode 100644
index 0000000..a1886dc
--- /dev/null
+++ b/src/components/workspace/abiInputs/Null.tsx
@@ -0,0 +1,42 @@
+import { Form, Input } from 'antd';
+import { RuleObject } from 'antd/es/form';
+
+interface Props {
+  name?: string;
+  placeholder?: string;
+  className?: string;
+}
+
+const NullInput = ({
+  name = 'buffer',
+  placeholder = 'HEX or base64 bytes',
+  className = '',
+}: Props) => {
+  const rules = [
+    { required: true },
+    () => ({
+      validator(_rule: RuleObject, value: string) {
+        if (!value) return Promise.resolve();
+        // first try to parse as hex. if fails, try to parse as base64
+        try {
+          Buffer.from(value, 'hex');
+        } catch {
+          try {
+            Buffer.from(value, 'base64');
+          } catch {
+            return Promise.reject('Invalid');
+          }
+        }
+
+        return Promise.resolve();
+      },
+    }),
+  ];
+  return (
+    <Form.Item name={name} rules={rules} className={className}>
+      <Input placeholder={placeholder} readOnly />
+    </Form.Item>
+  );
+};
+
+export default NullInput;
diff --git a/src/components/workspace/abiInputs/String.tsx b/src/components/workspace/abiInputs/String.tsx
new file mode 100644
index 0000000..c3d3edb
--- /dev/null
+++ b/src/components/workspace/abiInputs/String.tsx
@@ -0,0 +1,34 @@
+import { Form, Input } from 'antd';
+import { RuleObject } from 'antd/es/form';
+
+interface Props {
+  name?: string;
+  placeholder?: string;
+  className?: string;
+}
+
+const StringInput = ({
+  name = 'abc',
+  placeholder = 'abc',
+  className = '',
+}: Props) => {
+  const rules = [
+    { required: true },
+    () => ({
+      validator(_rule: RuleObject, value: string) {
+        if (typeof value !== 'string') {
+          return Promise.reject('Invalid value');
+        }
+
+        return Promise.resolve();
+      },
+    }),
+  ];
+  return (
+    <Form.Item name={name} rules={rules} className={className}>
+      <Input placeholder={placeholder} />
+    </Form.Item>
+  );
+};
+
+export default StringInput;
diff --git a/src/components/workspace/abiInputs/index.ts b/src/components/workspace/abiInputs/index.ts
new file mode 100644
index 0000000..8d66dc3
--- /dev/null
+++ b/src/components/workspace/abiInputs/index.ts
@@ -0,0 +1,7 @@
+export { default as AddressInput } from './Address';
+export { default as AmountInput } from './Amount';
+export { default as BoolInput } from './Bool';
+export { default as BufferInput } from './Buffer';
+export { default as CellInput } from './Cell';
+export { default as NullInput } from './Null';
+export { default as StringInput } from './String';
diff --git a/src/hooks/contract.hooks.ts b/src/hooks/contract.hooks.ts
index 173c6b8..5445f5d 100644
--- a/src/hooks/contract.hooks.ts
+++ b/src/hooks/contract.hooks.ts
@@ -5,9 +5,13 @@ import {
   ParameterType,
   Project,
 } from '@/interfaces/workspace.interface';
-import { capitalizeFirstLetter } from '@/utility/utils';
+import { capitalizeFirstLetter, convertToText } from '@/utility/utils';
 import { Network, getHttpEndpoint } from '@orbs-network/ton-access';
-import { SandboxContract, TreasuryContract } from '@ton-community/sandbox';
+import {
+  SandboxContract,
+  SendMessageResult,
+  TreasuryContract,
+} from '@ton-community/sandbox';
 import { ITonConnect, SendTransactionRequest } from '@tonconnect/sdk';
 import { useTonConnectUI } from '@tonconnect/ui-react';
 import { message } from 'antd';
@@ -24,6 +28,7 @@ import {
   TupleItem,
   beginCell,
   contractAddress,
+  fromNano,
   storeStateInit,
   toNano,
 } from 'ton-core';
@@ -42,16 +47,21 @@ export function useContractAction() {
     dataCell: string,
     network: Network | Partial<NetworkEnvironment>,
     project: Project
-  ): Promise<{ address: string; contract?: SandboxContract<UserContract> }> {
+  ): Promise<{
+    address: string;
+    contract?: SandboxContract<UserContract>;
+    logs?: string[];
+  }> {
     const { sandboxBlockchain, sandboxWallet } = globalWorkspace;
     let codeCell = Cell.fromBoc(Buffer.from(codeBOC, 'base64'))[0];
 
+    let sender: Sender | null = null;
+
     // Amount to send to contract. Gas fee
     const value = toNano('0.02');
     let stateInit: StateInit = {};
     if (project.language === 'tact') {
       const _contractInit = (window as any).contractInit;
-      console.log('_contractInit', _contractInit);
       stateInit = {
         code: _contractInit.init.code,
         data: _contractInit.init.data,
@@ -63,59 +73,92 @@ export function useContractAction() {
       };
     }
 
-    if (network.toUpperCase() === 'SANDBOX' && sandboxBlockchain) {
-      if (project.language === 'tact') {
-        const _contractInit = (window as any).contractInit;
-        const _userContract = sandboxBlockchain.openContract(_contractInit);
-        // TODO: Handle last parameter i.e. message
-        const sender = sandboxWallet!!.getSender();
-        const queryId = BigInt(0);
-        let messageParams = {};
-        if (project?.initParams && project?.initParams?.length > 0) {
-          const hasQueryId = project?.initParams?.findIndex(
-            (item) => item.name == 'queryId'
-          );
-          if (hasQueryId > -1) {
-            messageParams = {
-              $$type: 'Deploy',
-              queryId,
-            };
-          } else {
-            messageParams = {
-              $$type: 'Deploy',
-            };
-          }
-        }
-
-        const response = await _userContract.send(
-          sender,
-          {
-            value,
-          },
-          messageParams
-        );
+    let messageParams = {};
+    const _contractInit = (window as any).contractInit;
+    let _userContract: any = null;
 
-        return {
-          address: _userContract.address.toString(),
-          contract: _userContract,
+    if (project?.initParams && project?.initParams?.length > 0) {
+      const hasQueryId = project?.initParams?.findIndex(
+        (item) => item.name == 'queryId'
+      );
+      const queryId = BigInt(0);
+      if (hasQueryId > -1) {
+        messageParams = {
+          $$type: 'Deploy',
+          queryId,
         };
       } else {
-        const _userContract = UserContract.createForDeploy(
-          stateInit.code as Cell,
-          stateInit.data as Cell
-        );
-        const userContract = sandboxBlockchain.openContract(_userContract);
-        const response = await userContract.sendData(
-          sandboxWallet!!.getSender()
+        messageParams = {
+          $$type: 'Deploy',
+        };
+      }
+    }
+
+    if (project.language === 'tact' && network.toUpperCase() !== 'SANDBOX') {
+      sender = new TonConnectSender(tonConnector.connector);
+      const endpoint = await getHttpEndpoint({
+        network: network?.toLocaleLowerCase() as Network,
+      });
+
+      const client = new TonClient({ endpoint });
+      _userContract = client.open(_contractInit);
+      client;
+    } else if (network.toUpperCase() === 'SANDBOX' && sandboxBlockchain) {
+      _userContract = sandboxBlockchain.openContract(_contractInit);
+      sender = sandboxWallet!!.getSender();
+    }
+
+    if (project.language === 'tact') {
+      const response = await _userContract.send(
+        sender,
+        {
+          value,
+        },
+        messageParams
+      );
+      let logMessages: string[] = [];
+      if (response) {
+        logMessages = terminalLogMessages(
+          [response],
+          [_userContract as Contract]
         );
-        if (network.toUpperCase() !== 'SANDBOX') {
-          message.success('Contract Deployed');
+      }
+
+      // create a code loop through array and check has error string
+      for (let index = 0; index < logMessages.length; index++) {
+        const element = logMessages[index];
+        if (element.includes('Error')) {
+          return {
+            address: '',
+            contract: _userContract,
+            logs: logMessages,
+          };
         }
-        return {
-          address: _userContract.address.toString(),
-          contract: userContract,
-        };
       }
+
+      return {
+        address: _userContract.address.toString(),
+        contract: _userContract,
+        logs: logMessages,
+      };
+    }
+
+    if (network.toUpperCase() === 'SANDBOX' && sandboxBlockchain) {
+      //  else {
+      const _userContract = UserContract.createForDeploy(
+        stateInit.code as Cell,
+        stateInit.data as Cell
+      );
+      const userContract = sandboxBlockchain.openContract(_userContract);
+      const response = await userContract.sendData(sandboxWallet!!.getSender());
+      if (network.toUpperCase() !== 'SANDBOX') {
+        message.success('Contract Deployed');
+      }
+      return {
+        address: _userContract.address.toString(),
+        contract: userContract,
+      };
+      // }
     }
 
     const _contractAddress = contractAddress(0, stateInit);
@@ -201,7 +244,7 @@ export function useContractAction() {
     kind?: string,
     stack?: TupleItem[],
     network?: Network | Partial<NetworkEnvironment>
-  ) {
+  ): Promise<{ message: string; logs?: string[] } | undefined> {
     if (language === 'tact' && contract) {
       let sender: Sender | null = null;
 
@@ -221,19 +264,29 @@ export function useContractAction() {
       stack?.forEach((item: any) => {
         messageParams = {
           ...messageParams,
-          [item.name]: BigInt(item.value),
+          [item.name]: BigInt(item.value || 0),
         };
       });
 
       const response = await (contract as any).send(
         sender,
-        { value: toNano('0.02') },
+        { value: toNano('0.1') },
         messageParams
       );
-      return { message: 'Message sent successfully' };
+      return {
+        message: 'Message sent successfully',
+        logs: terminalLogMessages([response], [contract as Contract]),
+      };
     }
   }
 
+  function parseInt(item: any, language: ContractLanguage) {
+    if (language === 'tact') {
+      return new BN(item.value.toString());
+    }
+    return BigInt((item as any).value);
+  }
+
   async function callGetter(
     contractAddress: string,
     methodName: string,
@@ -242,13 +295,14 @@ export function useContractAction() {
     kind?: string,
     stack?: TupleItem[],
     network?: Network | Partial<NetworkEnvironment>
-  ) {
+  ): Promise<{ message: string; logs?: string[] } | undefined | any> {
+    console.log(stack, 'stack');
     const parsedStack = stack?.map((item) => {
       switch (item.type as ParameterType) {
         case 'int':
           return {
             type: item.type,
-            value: new BN((item as any).value.toString()),
+            value: parseInt(item, language),
           };
         case 'address':
           return {
@@ -270,10 +324,13 @@ export function useContractAction() {
       let responseValues = [];
       if (language === 'tact') {
         // convert getter function name as per script function name. Ex. counter will become getCounter
-        const response = await (contract as any)[
-          'get' + capitalizeFirstLetter(methodName)
-        ]();
-        responseValues.push({ method: methodName, value: response.toString() });
+        const params = parsedStack?.map((item) => item.value);
+        const _method = ('get' + capitalizeFirstLetter(methodName)) as any;
+        const response = await (contract as any)[_method](params);
+        responseValues.push({
+          method: methodName,
+          value: convertToText(response),
+        });
       } else {
         const call = await contract.getData(methodName, parsedStack as any);
         while (call.stack.remaining) {
@@ -362,7 +419,7 @@ function parseReponse(tupleItem: TupleItem) {
 }
 
 class TonConnectSender implements Sender {
-  provider: ITonConnect;
+  public provider: ITonConnect;
   readonly address?: Address;
 
   constructor(provider: ITonConnect) {
@@ -403,3 +460,155 @@ class TonConnectSender implements Sender {
     });
   }
 }
+
+// Credit for below log message parsing: https://github.com/tact-lang/tact-by-example/blob/main/src/routes/(examples)/%2Blayout.svelte
+function terminalLogMessages(
+  results: SendMessageResult[] = [],
+  contractInstances: Contract[]
+) {
+  const messages = [];
+  for (const result of results) {
+    for (const transaction of result.transactions) {
+      if (
+        transaction.inMessage?.info.type == 'internal' ||
+        transaction.inMessage?.info.type == 'external-in'
+      ) {
+        if (transaction.inMessage?.info.type == 'internal') {
+          if (transaction.debugLogs) {
+            const splittedLog = transaction.debugLogs.split('\n');
+            for (let i = 0; i < splittedLog.length; i++) {
+              messages.push(splittedLog[i]);
+            }
+          }
+          if (transaction.description.type == 'generic') {
+            if (transaction.description.computePhase.type == 'vm') {
+              // get the computational result of the transaction
+              const compute = transaction.description.computePhase;
+              if (compute.exitCode == 4294967282) compute.exitCode = -14;
+              messages.push(
+                `Transaction Executed: ${
+                  compute.success ? 'success' : 'error'
+                }, ` +
+                  `Exit Code: ${compute.exitCode}, Gas: ${shorten(
+                    compute.gasFees,
+                    'coins'
+                  )}`
+              );
+              let foundError = false;
+              for (const contractInstance of contractInstances) {
+                if (
+                  transaction.inMessage?.info.dest.equals(
+                    contractInstance.address
+                  )
+                ) {
+                  if (compute.exitCode == -14) compute.exitCode = 13;
+                  const message =
+                    contractInstance?.abi?.errors?.[compute.exitCode]?.message;
+                  if (message) {
+                    messages.push(`🔴 Error message: ${message}\n`);
+                    foundError = true;
+                  }
+                }
+              }
+              if (!foundError) {
+                const knownErrors: { [code: number]: { message: string } } = {
+                  [-14]: { message: `Out of gas error` },
+                  2: { message: `Stack undeflow` },
+                  3: { message: `Stack overflow` },
+                  4: { message: `Integer overflow` },
+                  5: { message: `Integer out of expected range` },
+                  6: { message: `Invalid opcode` },
+                  7: { message: `Type check error` },
+                  8: { message: `Cell overflow` },
+                  9: { message: `Cell underflow` },
+                  10: { message: `Dictionary error` },
+                  13: { message: `Out of gas error` },
+                  32: { message: `Method ID not found` },
+                  34: { message: `Action is invalid or not supported` },
+                  37: { message: `Not enough TON` },
+                  38: { message: `Not enough extra-currencies` },
+                  128: { message: `Null reference exception` },
+                  129: { message: `Invalid serialization prefix` },
+                  130: { message: `Invalid incoming message` },
+                  131: { message: `Constraints error` },
+                  132: { message: `Access denied` },
+                  133: { message: `Contract stopped` },
+                  134: { message: `Invalid argument` },
+                  135: { message: `Code of a contract was not found` },
+                  136: { message: `Invalid address` },
+                  137: {
+                    message: `Masterchain support is not enabled for this contract`,
+                  },
+                };
+                const message = knownErrors[compute.exitCode]?.message;
+                if (message) {
+                  messages.push(`Error message: ${message}`);
+                  foundError = true;
+                }
+              }
+            }
+          }
+        }
+        for (let i = 0; i < transaction.outMessagesCount; i++) {
+          const outMessage = transaction.outMessages.get(i);
+          if (outMessage?.info.type == 'external-out') {
+            if (outMessage.info.dest == null) {
+              const name = messageName(outMessage.body, contractInstances);
+              messages.push(
+                `Log emitted: ${name}, from ${shorten(outMessage.info.src)}`
+              );
+            }
+          }
+        }
+        for (const event of transaction.events) {
+          if (event.type == 'message_sent') {
+            const name = messageName(event.body, contractInstances);
+            messages.push(
+              `Message sent: ${name}, from ${shorten(event.from)}, to ${shorten(
+                event.to
+              )}, ` +
+                `value ${shorten(event.value, 'coins')}, ${
+                  event.bounced ? '' : 'not '
+                }bounced`
+            );
+          }
+        }
+      }
+    }
+  }
+  return messages;
+}
+
+function messageName(body: Cell, contractInstances: Contract[]): string {
+  try {
+    const slice = body.beginParse();
+    let op = slice.loadInt(32);
+    if (op == 0) {
+      return `"${slice.loadStringTail()}"`;
+    }
+    if (op < 0) op += 4294967296;
+    for (const contractInstance of contractInstances) {
+      for (const type of contractInstance?.abi?.types ?? []) {
+        if (op == type.header) return type.name;
+      }
+    }
+    if (op == 0xffffffff) {
+      return 'error';
+    }
+    return `unknown (0x${op.toString(16)})`;
+  } catch (e) {}
+  return 'empty';
+}
+
+function shorten(
+  long: Address | bigint,
+  format: 'default' | 'coins' = 'default'
+) {
+  if (long instanceof Address) {
+    return `${long.toString().slice(0, 4)}..${long.toString().slice(-4)}`;
+  }
+  if (typeof long == 'bigint') {
+    if (format == 'default') return long.toString();
+    if (format == 'coins') return fromNano(long);
+  }
+}
diff --git a/src/hooks/project.hooks.ts b/src/hooks/project.hooks.ts
index 881dcba..01dc15a 100644
--- a/src/hooks/project.hooks.ts
+++ b/src/hooks/project.hooks.ts
@@ -183,6 +183,14 @@ export function useProjectActions() {
 
     const fs = new OverwritableVirtualFileSystem(fileList);
 
+    let ctx = new CompilerContext({ shared: {} });
+    let stdlib = createVirtualFileSystem('@stdlib', stdLibFiles);
+    try {
+      ctx = precompile(ctx, fs, stdlib, file.path!!);
+    } catch (error: any) {
+      throw error;
+    }
+
     const response = await buildTact({
       config: {
         path: file.path!!,
@@ -195,6 +203,9 @@ export function useProjectActions() {
       project: fs,
       stdlib: '@stdlib',
     });
+    if (!response) {
+      throw new Error('Error while building');
+    }
 
     let output = {
       abi: '',
@@ -265,9 +276,6 @@ export function useProjectActions() {
       }
     });
 
-    let ctx = new CompilerContext({ shared: {} });
-    let stdlib = createVirtualFileSystem('@stdlib', stdLibFiles);
-    ctx = precompile(ctx, fs, stdlib, file.path!!);
     const _contract = getContracts(ctx);
     const contactType = getType(ctx, _contract[0]);
 
@@ -430,7 +438,7 @@ const importUserFile = async (
     files.push(currentFile);
   }
 
-  let commonFiles: any = [];
+  let commonFiles: any = { files: [], filesWithId: [] };
 
   if (language !== 'tact') {
     commonFiles = createTemplateBasedProject(
diff --git a/src/pages/_app.tsx b/src/pages/_app.tsx
index 0e4be92..f4d80ad 100644
--- a/src/pages/_app.tsx
+++ b/src/pages/_app.tsx
@@ -91,7 +91,7 @@ export default function App({
           }}
         >
           <TonConnectUIProvider
-            uiPreferences={{ theme: THEME.DARK }}
+            uiPreferences={{ theme: THEME.LIGHT }}
             manifestUrl="https://ton-ide-nujan.vercel.app/assets/ton/tonconnect-manifest.json"
           >
             <Layout>
diff --git a/src/utility/utils.ts b/src/utility/utils.ts
index 24f8681..72e6777 100644
--- a/src/utility/utils.ts
+++ b/src/utility/utils.ts
@@ -1,5 +1,6 @@
 import { FileExtensionToFileType, FileType } from '@/enum/file';
 import { NetworkEnvironment } from '@/interfaces/workspace.interface';
+import { Address, Cell, Dictionary, Slice } from 'ton-core';
 
 export function fileTypeFromFileName(name: string): FileType {
   return fileTypeForExtension(name.split('.').pop() || '');
@@ -143,3 +144,52 @@ export const capitalizeFirstLetter = (inputString: string) => {
 
   return firstLetter + restOfTheString;
 };
+
+export const convertToText = (obj: any): string => {
+  //create an array that will later be joined into a string.
+  var string = [];
+
+  //is object
+  //    Both arrays and objects seem to return "object"
+  //    when typeof(obj) is applied to them. So instead
+  //    I am checking to see if they have the property
+  //    join, which normal objects don't have but
+  //    arrays do.
+  if (obj == undefined) {
+    return String(obj);
+  } else if (typeof obj == "object" && obj.join == undefined) {
+    if (obj instanceof Address) return obj.toString();
+    if (obj instanceof Slice) return obj.toString();
+    if (obj instanceof Cell) return obj.toString();
+    if (obj instanceof Dictionary) {
+      const items = [];
+      for (const key of obj.keys()) items.push(`${convertToText(key)}: ${convertToText(obj.get(key))}`);
+      const itemsStr = items.join(", ");
+      return itemsStr ? `{ ${itemsStr} }` : `{}`;
+    }
+
+    for (const prop in obj) {
+      if (obj.hasOwnProperty(prop)) string.push(prop + ": " + convertToText(obj[prop]));
+    }
+    return "{" + string.join(", ") + "}";
+
+    //is array
+  } else if (typeof obj == "object" && !(obj.join == undefined)) {
+    for (const prop in obj) {
+      string.push(convertToText(obj[prop]));
+    }
+    return "[" + string.join(",") + "]";
+
+    //is function
+  } else if (typeof obj == "function") {
+    string.push(obj.toString());
+
+    //all other values can be done with JSON.stringify
+  } else {
+    if (typeof obj == "string") string.push(JSON.stringify(obj));
+    else if (typeof obj == "bigint") string.push(obj.toString());
+    else string.push(obj.toString());
+  }
+
+  return string.join(",");
+}
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
index 2159bf4..6b161ff 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "target": "es2020",
     "lib": ["dom", "dom.iterable", "esnext"],
     "allowJs": true,
     "skipLibCheck": true,