import custom deployment (#245)

* Fix contract_name input

* Create custom contract fn

* Merging the loop solution in home

* Refactoring

* Fixing name typo error

* Adding toast notification

* Fixing newDeploy on Step3

* Parsin Record to json string

* fix layout

* Fixing custom Token img on contracts table

* Adding useForm

* Fixing deploy psp contracts

* Fix typo on Routes

---------

Co-authored-by: Agustín Longoni <[email protected]>

src/constants/config.ts

@@ -41,6 +41,10 @@ const backendRouterApi = {
   updateDeployment: {
     pathName: 'deployments',
     method: 'PATCH'
+  },
+  version: {
+    pathName: 'version',
+    method: 'GET'
   }
 }
 

src/constants/routes.ts

@@ -3,5 +3,6 @@ export const ROUTES = {
   WIZARD: '/wizard',
   DOCS: '/docs',
   CONTRACTS: '/contracts',
-  CUSTOM: '/custom-contract'
+  CUSTOM: '/custom-contract',
+  CONTRACTDETAIL: '/custom-contract/contract-detail'
 } as const

src/constants/titleTokenType.ts

@@ -30,7 +30,7 @@ export const TITLE_MAP_TOKEN: Record<ContractType, TitleMapProps> = {
   custom: {
     title: 'CUSTOM',
     subtitle: 'Standard smart contract for a custom Token',
-    imgPath: TOKEN_PATHS.psp37,
+    imgPath: TOKEN_PATHS.custom,
     imgProps: { width: 45, height: 39 }
   }
 }

src/context/ApiVersionContext.tsx

@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react'
+
+interface ApiVersionContextProps {
+  version: string | null
+}
+
+const ApiVersionContext = createContext<ApiVersionContextProps>({
+  version: null
+})
+
+export const useApiVersion = () => {
+  return useContext(ApiVersionContext)
+}
+
+export default ApiVersionContext

src/context/LocalDbContext.tsx

@@ -4,7 +4,13 @@ import {
   ApiDeploymentRepository,
   IApiDeploymentRepository
 } from '@/services/backendApi/ApiDeploymentRepository'
-import React, { createContext, PropsWithChildren, useContext } from 'react'
+import React, {
+  createContext,
+  PropsWithChildren,
+  useContext,
+  useEffect,
+  useState
+} from 'react'
 import { BACKEND_API } from '../constants'
 import { MyDatabase } from '@/services/localDB'
 import { UserContractsRepository } from '@/services/localDB/UserContractsRepository'
@@ -13,12 +19,14 @@ import {
   ApiCompileContractRepository,
   IApiCompileContractRepository
 } from '@/services/backendApi/ApiCompileContractRepository'
+import { apiVersionService } from '@/services/backendApi/ApiVersionService'
 
 interface DbContext {
   networkRepository: INetworkRepository
   deploymentsRepository: IApiDeploymentRepository
   userContractsRepository: IUserContractsRepository
   compileContractRepository: IApiCompileContractRepository
+  backendApiVersion: string
 }
 
 const networkRepository = new LocalStorageNetworkRepository()
@@ -30,17 +38,27 @@ const DbContext = createContext<DbContext>({
   networkRepository,
   deploymentsRepository,
   userContractsRepository,
-  compileContractRepository
+  compileContractRepository,
+  backendApiVersion: ''
 })
 
 export const LocalDbProvider: React.FC<PropsWithChildren> = ({ children }) => {
+  const [backendApiVersion, setBackendApiVersion] = useState('')
+
+  useEffect(() => {
+    void apiVersionService
+      .getApiVersion()
+      .then(version => setBackendApiVersion(version))
+  }, [])
+
   return (
     <DbContext.Provider
       value={{
         networkRepository,
         deploymentsRepository,
         userContractsRepository,
-        compileContractRepository
+        compileContractRepository,
+        backendApiVersion
       }}
     >
       {children}

src/domain/UserContractDetails.ts

@@ -1,27 +1,25 @@
-import { TokenType } from '@/domain/TokenType'
 import { ContractCompiledRaw } from '@/services'
 import { ContractType } from '@/domain/repositories/DeploymentRepository'
 import { ChainId } from '@/services/useink/chains'
 
 export type ContractMetadata = ContractCompiledRaw
 
 export interface UserContractDetails {
-  userAddress: string
-  blockchain: ChainId
-  address: string
-  txHash: string | undefined
-  codeHash: string
-  type: ContractType
+  uuid: string
   name: string
+  address: string
+  network: ChainId
+  codeId: string
+  userAddress: string
+  txHash?: string
   date: string
+  type: ContractType
   abi?: Record<string, unknown>
   external: boolean // Contracts not deployed by PCW are custom and external
   hidden: boolean
 }
 
-export type ContractCompiled = Pick<
+export type UserContractDetailsDraft = Omit<
   UserContractDetails,
-  'userAddress' | 'codeHash' | 'name' | 'name'
-> & {
-  type: TokenType
-}
+  'uuid' | 'external'
+>

src/domain/common/OnCallbacks.ts

@@ -0,0 +1,5 @@
+export interface OnCallbacks<I> {
+  onStartCallback?: () => void
+  onSuccessCallback?: (result: I) => void
+  onErrorCallback?: (e: unknown) => void
+}

src/domain/repositories/DeploymentRepository.ts

@@ -1,24 +1,12 @@
 import { ChainId } from '@/services/useink/chains'
 import { TokenType } from '../TokenType'
+import { UserContractDetailsDraft } from '../UserContractDetails'
 
 export type ContractType = TokenType | 'custom'
-export type UpdateDeployment = Partial<DeploymentItem>
-
-export interface DeploymentItem {
-  contractName: string
-  contractAddress: string
-  network: ChainId
-  codeId: string
-  userAddress: string
-  txHash?: string
-  date: string
-  contractType: ContractType
-  externalAbi?: Record<string, unknown>
-  hidden: boolean
-}
+export type UpdateDeployment = Partial<UserContractDetailsDraft>
 
 export interface IDeploymentsRepository<A, B> {
-  add: (deployment: DeploymentItem) => Promise<A>
-  findBy: (userAddress: string, networkId?: ChainId) => Promise<B>
+  add: (deployment: UserContractDetailsDraft) => Promise<A>
+  findBy: (userAddress: string, network?: ChainId) => Promise<B>
   updateBy: (deployment: UpdateDeployment) => Promise<A>
 }

src/domain/repositories/IUserContractsRepository.ts

@@ -1,19 +1,22 @@
 import { ChainId } from '@/services/useink/chains'
-import { UserContractDetails } from '../UserContractDetails'
-import { DeploymentItem, UpdateDeployment } from './DeploymentRepository'
+import {
+  UserContractDetails,
+  UserContractDetailsDraft
+} from '../UserContractDetails'
+import { UpdateDeployment } from './DeploymentRepository'
 import { FilterType } from '@/services/localDB/UserContractsRepository'
 
 export interface IUserContractsRepository {
   add: (deployment: UserContractDetails) => Promise<string>
   list: (userAddress: string) => Promise<UserContractDetails[]>
   searchBy: (
     userAddress: string,
-    networkId: ChainId,
+    network: ChainId,
     filterBy?: FilterType
   ) => Promise<UserContractDetails[]>
   bulkAddByUser(
     userAddress: string,
-    deployments: DeploymentItem[]
+    deployments: UserContractDetailsDraft[]
   ): Promise<UserContractDetails[]>
 
   updateBy(deployment: UpdateDeployment): Promise<number>

src/hooks/deployments/useCreateDeployments.ts

@@ -0,0 +1,61 @@
+import { useCallback, useState } from 'react'
+
+import { useLocalDbContext } from '@/context/LocalDbContext'
+import { useAddUserContracts } from '@/hooks/userContracts/useAddUserContracts'
+import { deploymentItemToUserContractDetails } from '@/services/transformers/toUserContractDetails'
+import { UserContractDetailsDraft } from '@/domain'
+import { OnCallbacks } from '@/domain/common/OnCallbacks'
+
+interface NewDeploymentProps extends OnCallbacks<string> {
+  userContract: UserContractDetailsDraft
+}
+
+interface UseServiceAddDeployment {
+  newDeployment: (props: NewDeploymentProps) => Promise<string | undefined>
+  isLoading: boolean
+  error?: string
+}
+
+export function useCreateDeployments(): UseServiceAddDeployment {
+  const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<string | undefined>()
+  const { deploymentsRepository } = useLocalDbContext()
+  const { addUserContract } = useAddUserContracts()
+
+  const newDeployment = useCallback(
+    async ({
+      userContract,
+      onSuccessCallback,
+      onErrorCallback
+    }: NewDeploymentProps): Promise<string | undefined> => {
+      setError(undefined)
+      setIsLoading(true)
+
+      try {
+        const response = await deploymentsRepository.add(userContract)
+        if (response.error) {
+          throw Error(response.error.message)
+        }
+
+        const newDeployId = response['data']
+        const userContractWithId = deploymentItemToUserContractDetails(
+          userContract,
+          newDeployId
+        )
+        addUserContract(userContractWithId)
+
+        onSuccessCallback?.(newDeployId)
+        return newDeployId
+      } catch (error) {
+        const _errorMsg = `An error occurred when trying to upload the deployed contract on the server`
+        setError(_errorMsg)
+        onErrorCallback?.(error)
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [addUserContract, deploymentsRepository]
+  )
+
+  return { newDeployment, isLoading, error }
+}

src/hooks/deployments/useListContractsDeployments.ts → src/hooks/deployments/useListDeployments.ts

@@ -1,33 +1,33 @@
 import { useCallback, useState } from 'react'
 
-import { DeploymentItem } from '@/domain/repositories/DeploymentRepository'
 import { useLocalDbContext } from '@/context/LocalDbContext'
 import { getErrorMessage } from '@/utils/error'
 import { ChainId } from '@/services/useink/chains'
+import { UserContractDetails } from '@/domain'
 
 interface UseAddDeployment {
   userContractsFromApi: (
     userAddress: string,
     networkId?: ChainId
-  ) => Promise<DeploymentItem[] | undefined>
+  ) => Promise<UserContractDetails[] | undefined>
   isLoading: boolean
   error?: string
 }
 
-export function useListContractDeployments(): UseAddDeployment {
+export function useListDeployments(): UseAddDeployment {
   const [isLoading, setIsLoading] = useState(false)
   const [error, setError] = useState<string | undefined>()
   const { deploymentsRepository } = useLocalDbContext()
 
   const userContractsFromApi = useCallback(
-    async (userAddress: string, networkId?: ChainId) => {
+    async (userAddress: string, network?: ChainId) => {
       setIsLoading(true)
       setError(undefined)
 
       try {
         const deployments = await deploymentsRepository.findBy(
           userAddress,
-          networkId
+          network
         )
         return deployments
       } catch (e) {

src/hooks/deployments/useUpdateContractsDeployments.ts

@@ -22,13 +22,7 @@ export function useUpdateContractsDeployments(): UseAddDeployment {
       setIsLoading(true)
       setError(undefined)
       try {
-        const deployments = await deploymentsRepository.updateBy({
-          contractAddress: deployed.contractAddress,
-          userAddress: deployed.userAddress,
-          network: deployed.network,
-          contractName: deployed.contractName,
-          hidden: deployed.hidden
-        })
+        const deployments = await deploymentsRepository.updateBy(deployed)
         return deployments
       } catch (e) {
         setError(getErrorMessage(e))