add(offers): use unsued offered nft tokens

components/trade/makeOffer/MakeOfferModal.vue

@@ -59,11 +59,12 @@
 
 <script setup lang="ts">
 import { NeoModal } from '@kodadot1/brick'
+import { shuffle } from 'lodash'
 import type { MakingOfferItem } from '@/components/trade/types'
 import MakeOfferSingleItem from '@/components/trade/makeOffer/MakeOfferSingleItem.vue'
 import ModalBody from '@/components/shared/modals/ModalBody.vue'
 import { usePreferencesStore } from '@/stores/preferences'
-import type { Actions, TokenToOffer } from '@/composables/transaction/types'
+import type { ActionOffer, TokenToOffer } from '@/composables/transaction/types'
 import { useMakingOfferStore } from '@/stores/makeOffer'
 import format, { calculateBalance } from '@/utils/format/balance'
 import { warningMessage } from '@/utils/notification'
@@ -98,13 +99,17 @@ const { itemsInChain, hasInvalidOfferPrices, count } = storeToRefs(offerStore)
 const { decimals, chainSymbol } = useChain()
 const { $i18n } = useNuxtApp()
 const items = ref<MakingOfferItem[]>([])
+const unusedOfferedItemsSubscription = ref(() => {})
+const usedOfferedItems = ref<string[]>([])
+const offeredItem = ref<string>()
 
-const getAction = (items: MakingOfferItem[]): Actions => {
+const getAction = (items: MakingOfferItem[]): ActionOffer => {
   return {
     interaction: ShoppingActions.MAKE_OFFER,
     urlPrefix: urlPrefix.value,
     token: items.map(item => ({
       price: String(calculateBalance(Number(item.offerPrice), decimals.value)),
+      offeredItem: offeredItem.value,
       collectionId: item.collection.id,
       duration: item.offerExpiration || 7,
       nftSn: item.sn,
@@ -120,15 +125,15 @@ const teleportTransitionTxFees = computed(() =>
   ),
 )
 
-const { action, autoTeleport, autoTeleportButton, autoTeleportLoaded } = useAutoTeleportActionButton({
+const { action, autoTeleport, autoTeleportButton, autoTeleportLoaded } = useAutoTeleportActionButton<ActionOffer>({
   getActionFn: () => getAction(itemsInChain.value),
 })
 
 const totalOfferAmount = computed(
   () => calculateBalance(sum(itemsInChain.value.map(nft => Number(nft.offerPrice))), decimals.value),
 )
 
-const totalNeededAmount = computed(() => totalOfferAmount.value + OFFER_MINT_PRICE)
+const totalNeededAmount = computed(() => totalOfferAmount.value + (!offeredItem.value ? OFFER_MINT_PRICE : 0))
 
 const actions = computed<AutoTeleportAction[]>(() => [
   {
@@ -176,6 +181,7 @@ const submitOffer = () => {
 async function confirm({ autoteleport }: AutoTeleportActionButtonConfirmEvent) {
   try {
     clearTransaction()
+    unusedOfferedItemsSubscription.value()
 
     autoTeleport.value = autoteleport
     items.value = [...itemsInChain.value]
@@ -210,6 +216,47 @@ useModalIsOpenTracker({
   isOpen: computed(() => preferencesStore.makeOfferModalOpen),
   onChange: () => {
     offerStore.clear()
+    unusedOfferedItemsSubscription.value()
+  },
+})
+
+useModalIsOpenTracker({
+  isOpen: computed(() => preferencesStore.makeOfferModalOpen),
+  onClose: false,
+  onChange: () => {
+    unusedOfferedItemsSubscription.value = useSubscriptionGraphql({
+      query: `
+      offers(where: {
+        status_not_in: [ACTIVE, ACCEPTED]
+        caller_eq: "${accountId.value}"
+      }) {
+        nft {
+          sn
+        }
+      }`,
+      onChange: ({ data: { offers: items } }) => {
+        const tokensSn = items
+          .map(({ nft }) => nft.sn)
+          .filter((tokenSn: string) => !usedOfferedItems.value.includes(tokenSn))
+
+        const unusedOfferedItems = shuffle(tokensSn)
+
+        offeredItem.value = unusedOfferedItems[0]
+      },
+    })
+  },
+})
+
+useTransactionTracker({
+  transaction: {
+    isError,
+    status,
+  },
+  onSuccess: () => {
+    if (offeredItem.value) {
+      usedOfferedItems.value.push(offeredItem.value)
+      offeredItem.value = undefined
+    }
   },
 })
 

composables/autoTeleport/useAutoTeleportActionButton.ts

@@ -1,14 +1,14 @@
 import type { Actions } from '@/composables/transaction/types'
 
-export default ({
+export default <T = Actions>({
   getActionFn,
 }) => {
   const { decimals, chainSymbol } = useChain()
 
   const autoTeleport = ref(false)
   const autoTeleportButton = ref()
   const autoTeleportLoaded = ref(false)
-  const action = ref<Actions>(emptyObject<Actions>())
+  const action = ref<T>(emptyObject<T>())
 
   const txFees = computed(() => autoTeleportButton.value?.optimalTransition.txFees || 0)
   const { formatted: formattedTxFees } = useAmount(txFees, decimals, chainSymbol)

composables/transaction/transactionOffer.ts

@@ -1,3 +1,5 @@
+import type { ApiPromise } from '@polkadot/api'
+import type { SubmittableExtrinsic } from '@polkadot/api-base/types'
 import type { Prefix } from '@kodadot1/static'
 import type { ActionOffer } from './types'
 import { generateId } from '@/services/dyndata'
@@ -17,35 +19,44 @@ export const OFFER_MINT_PRICE = 5e8
 
 const BLOCKS_PER_DAY = 300 * 24 // 12sec /block --> 300blocks/hr
 
-async function execMakingOffer(item: ActionOffer, api, executeTransaction) {
+async function execMakingOffer(item: ActionOffer, api: ApiPromise, executeTransaction) {
   const { accountId } = useAuth()
   const nfts = Array.isArray(item.token) ? item.token : [item.token]
   const transactions = await Promise.all(
-    nfts.map(async ({ price, nftSn, collectionId, duration }) => {
-      const offerId = getOfferCollectionId(item.urlPrefix as Prefix)
-      const nextId = Number.parseInt(await generateId())
-      const create = api.tx.nfts.mint(
-        offerId,
-        nextId,
-        accountId.value,
-        {
-          mintPrice: String(OFFER_MINT_PRICE),
-        },
-      )
+    nfts.map(async ({ price, nftSn: desiredItem, collectionId: desiredCollectionId, duration, offeredItem: offeredSn }) => {
+      const offeredCollectionId = getOfferCollectionId(item.urlPrefix as Prefix)
+      let offeredItem = Number(offeredSn)
+
+      const transactions: SubmittableExtrinsic<'promise'>[] = []
+
+      if (!offeredItem) {
+        offeredItem = Number.parseInt(await generateId())
+        const create = api.tx.nfts.mint(
+          offeredCollectionId,
+          offeredItem,
+          accountId.value,
+          {
+            mintPrice: String(OFFER_MINT_PRICE),
+          },
+        )
+        transactions.push(create)
+      }
 
       const offer = api.tx.nfts.createSwap(
-        offerId,
-        nextId,
-        collectionId,
-        nftSn,
+        offeredCollectionId,
+        offeredItem,
+        desiredCollectionId,
+        desiredItem,
         {
           amount: Number(price) || 0,
           direction: 'Send',
         },
         BLOCKS_PER_DAY * duration,
       )
 
-      return [create, offer]
+      transactions.push(offer)
+
+      return transactions
     }),
   )
 

composables/transaction/types.ts

@@ -154,6 +154,7 @@ export type TokenToList = {
 
 export type TokenToOffer = {
   price: string
+  offeredItem?: string
   collectionId: string
   nftSn: string
   duration: number