delete unnecessary file

Author: Akira-Taniguchi

lib/ethereum/s-tokens/descriptors.spec.ts

@@ -7,15 +7,13 @@ import { createRewardsCaller } from './rewards'
 import { createTokenURICaller } from './tokenURI'
 import { createPositionsOfPropertyCaller } from './positionsOfProperty'
 import { createPositionsOfOwnerCaller } from './positionsOfOwner'
-import { createDescriptorsCaller } from './descriptors'
+import { createIsFreezedCaller } from './isFreezed'
 import { createFreezeTokenURICaller } from './freezeTokenURI'
-import { createMeltTokenURICaller } from './meltTokenURI'
 import { createSetTokenURIImageCaller } from './setTokenURIImage'
 
 jest.mock('./positions')
-jest.mock('./descriptors')
+jest.mock('./isFreezed')
 jest.mock('./freezeTokenURI')
-jest.mock('./meltTokenURI')
 jest.mock('./setTokenURIImage')
 jest.mock('./ownerOf')
 jest.mock('./rewards')
@@ -38,15 +36,12 @@ describe('s-tokens/index.ts', () => {
 	;(createPositionsOfOwnerCaller as jest.Mock).mockImplementation(
 		(contract) => contract
 	)
-	;(createDescriptorsCaller as jest.Mock).mockImplementation(
+	;(createIsFreezedCaller as jest.Mock).mockImplementation(
 		(contract) => contract
 	)
 	;(createFreezeTokenURICaller as jest.Mock).mockImplementation(
 		(contract) => contract
 	)
-	;(createMeltTokenURICaller as jest.Mock).mockImplementation(
-		(contract) => contract
-	)
 	;(createSetTokenURIImageCaller as jest.Mock).mockImplementation(
 		(contract) => contract
 	)
@@ -62,9 +57,8 @@ describe('s-tokens/index.ts', () => {
 				const contract = new ethers.Contract(address, [...sTokensAbi], provider)
 				return {
 					positions: createPositionsCaller(contract),
-					descriptors: createDescriptorsCaller(contract),
+					isFreezed: createIsFreezedCaller(contract),
 					freezeTokenURI: createFreezeTokenURICaller(contract),
-					meltTokenURI: createMeltTokenURICaller(contract),
 					setTokenURIImage: createSetTokenURIImageCaller(contract),
 					ownerOf: createOwnerOfCaller(contract),
 					rewards: createRewardsCaller(contract),

lib/ethereum/s-tokens/descriptors.ts

@@ -3,9 +3,8 @@ import { Provider } from '@ethersproject/abstract-provider'
 import { Signer } from '@ethersproject/abstract-signer'
 import { sTokensAbi } from './abi'
 import { createPositionsCaller, Positions } from './positions'
-import { createDescriptorsCaller, Descriptors } from './descriptors'
+import { createIsFreezedCaller } from './isFreezed'
 import { createFreezeTokenURICaller } from './freezeTokenURI'
-import { createMeltTokenURICaller } from './meltTokenURI'
 import { createSetTokenURIImageCaller } from './setTokenURIImage'
 import { createOwnerOfCaller } from './ownerOf'
 import { createRewardsCaller, Rewards } from './rewards'
@@ -15,9 +14,8 @@ import { createPositionsOfOwnerCaller } from './positionsOfOwner'
 
 export type STokensContract = {
 	readonly positions: (tokenId: number) => Promise<Positions>
-	readonly descriptors: (tokenId: number) => Promise<Descriptors>
+	readonly isFreezed: (tokenId: number) => Promise<boolean>
 	readonly freezeTokenURI: (tokenId: number) => Promise<boolean>
-	readonly meltTokenURI: (tokenId: number) => Promise<boolean>
 	readonly setTokenURIImage: (tokenId: number, data: string) => Promise<boolean>
 	readonly ownerOf: (tokenId: number) => Promise<string>
 	readonly rewards: (tokenId: number) => Promise<Rewards>
@@ -42,9 +40,8 @@ export const createSTokensContract =
 
 		return {
 			positions: createPositionsCaller(contractClient),
-			descriptors: createDescriptorsCaller(contractClient),
+			isFreezed: createIsFreezedCaller(contractClient),
 			freezeTokenURI: createFreezeTokenURICaller(contractClient),
-			meltTokenURI: createMeltTokenURICaller(contractClient),
 			setTokenURIImage: createSetTokenURIImageCaller(contractClient),
 			ownerOf: createOwnerOfCaller(contractClient),
 			rewards: createRewardsCaller(contractClient),

lib/ethereum/s-tokens/index.spec.ts

@@ -1,23 +1,22 @@
-import { createMeltTokenURICaller } from './meltTokenURI'
-import { stubbedSendTx } from '../../common/utils/for-test'
+import { createIsFreezedCaller } from './isFreezed'
 
-describe('meltTokenURI.spec.ts', () => {
-	describe('createMeltTokenURICaller', () => {
+describe('isFreezed.spec.ts', () => {
+	describe('createIsFreezedCaller', () => {
 		it('call success', async () => {
-			const success = true
+			const value = true
 			const tokenId = 1
 
 			const devContract = {
-				meltTokenURI: jest
+				// eslint-disable-next-line @typescript-eslint/no-unused-vars
+				isFreezed: jest
 					.fn()
-					// eslint-disable-next-line @typescript-eslint/no-unused-vars
-					.mockImplementation(async (tokenId: string) => stubbedSendTx()),
+					.mockImplementation(async (tokenId: string) => value),
 			}
 
-			const expected = success
+			const expected = value
 
 			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const caller = createMeltTokenURICaller(devContract as any)
+			const caller = createIsFreezedCaller(devContract as any)
 
 			const result = await caller(tokenId)
 
@@ -29,14 +28,14 @@ describe('meltTokenURI.spec.ts', () => {
 			const error = 'error'
 
 			const devContract = {
-				meltTokenURI: jest
+				isFreezed: jest
 					.fn()
 					// eslint-disable-next-line @typescript-eslint/no-unused-vars
 					.mockImplementation(async (tokenId: string) => Promise.reject(error)),
 			}
 
 			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const caller = createMeltTokenURICaller(devContract as any)
+			const caller = createIsFreezedCaller(devContract as any)
 
 			const result = await caller(tokenId).catch((err) => err)
 

lib/ethereum/s-tokens/index.ts

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+import { ethers } from 'ethers'
+import { execute, QueryOption } from '../../common/utils/execute'
+import { T } from 'ramda'
+
+export type CreateIsFreezedCaller = (
+	contract: ethers.Contract
+) => (tokenId: number) => Promise<boolean>
+
+export const createIsFreezedCaller: CreateIsFreezedCaller =
+	(contract: ethers.Contract) =>
+	async (tokenId: number): Promise<boolean> =>
+		execute<QueryOption>({
+			contract,
+			method: 'isFreezed',
+			args: [String(tokenId)],
+			mutation: false,
+		}).then(T)