autonomys
diff --git a/‎.gitmodules‎
Lines changed: 6 additions & 0 deletions b/‎.gitmodules‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎apps/backend/.env.test‎
Lines changed: 5 additions & 1 deletion b/‎apps/backend/.env.test‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎apps/backend/__tests__/e2e/uploads/folder.spec.ts‎
Lines changed: 16 additions & 0 deletions b/‎apps/backend/__tests__/e2e/uploads/folder.spec.ts‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎apps/backend/__tests__/e2e/users/credits.spec.ts‎
Lines changed: 55 additions & 1 deletion b/‎apps/backend/__tests__/e2e/users/credits.spec.ts‎
Lines changed: 55 additions & 1 deletion
diff --git a/‎apps/backend/__tests__/unit/useCases/intents.spec.ts‎
Lines changed: 232 additions & 0 deletions b/‎apps/backend/__tests__/unit/useCases/intents.spec.ts‎
Lines changed: 232 additions & 0 deletions
@@ -2,3 +2,9 @@
 	path = submodules/files-gateway
 	url = https://github.com/autonomys/auto-files-gateway.git
 	branch = v1.0.4
+[submodule "packages/contracts/lib/forge-std"]
+	path = packages/contracts/lib/forge-std
+	url = https://github.com/foundry-rs/forge-std
+[submodule "packages/contracts/lib/openzeppelin-contracts"]
+	path = packages/contracts/lib/openzeppelin-contracts
+	url = https://github.com/openzeppelin/openzeppelin-contracts
@@ -6,4 +6,8 @@ AUTH_SERVICE_API_KEY=mock_value
 AUTH_SERVICE_URL=https://example.com
 CACHE_DIR='.test-cache'
 FORBIDDEN_EXTENSIONS='exe,bin'
-DEBUG_LEVEL=info
+DEBUG_LEVEL=info
+STAFF_USERNAME_ALLOWLIST="none"
+STAFF_DOMAINS=autonomys.xyz
+EVM_CHAIN_ENDPOINT=http://example.org
+EVM_CHAIN_CONTRACT_ADDRESS=0x0000000000000000000000000000000000000000
@@ -300,6 +300,22 @@ describe('Folder Upload', () => {
           retriesLeft: expect.any(Number),
         })
       })
+
+      expect(rabbitMock).toHaveBeenCalledWith('task-manager', {
+        id: 'publish-nodes',
+        params: {
+          nodes: [subfileCID],
+        },
+        retriesLeft: expect.any(Number),
+      })
+
+      expect(rabbitMock).toHaveBeenCalledWith('task-manager', {
+        id: 'publish-nodes',
+        params: {
+          nodes: [subfolderCid],
+        },
+        retriesLeft: expect.any(Number),
+      })
     })
 
     it('upload status should be updated on node publishing', async () => {
 
@@ -1,4 +1,8 @@
-import { InteractionType, UserWithOrganization } from '@auto-drive/models'
+import {
+  InteractionType,
+  AccountModel,
+  UserWithOrganization,
+} from '@auto-drive/models'
 import { PreconditionError } from '../../utils/error.js'
 import { getDatabase } from '../../../src/infrastructure/drivers/pg.js'
 import {
@@ -8,6 +12,9 @@ import {
 } from '../../utils/mocks.js'
 import { dbMigration } from '../../utils/dbMigrate.js'
 import { AccountsUseCases } from '../../../src/core/users/accounts.js'
+import { AuthManager } from '../../../src/infrastructure/services/auth/index.js'
+import { accountsRepository } from '../../../src/infrastructure/repositories/index.js'
+import { jest } from '@jest/globals'
 
 describe('CreditsUseCases', () => {
   let mockUser: UserWithOrganization
@@ -67,4 +74,51 @@ describe('CreditsUseCases', () => {
 
     expect(initialCredits - pendingCredits).toBe(Number(size).valueOf())
   })
+
+  it('should add credits to a OneOff subscription', async () => {
+    jest.spyOn(AuthManager, 'getUserFromPublicId').mockResolvedValue(mockUser)
+    const subscription = await AccountsUseCases.getOrCreateAccount(mockUser)
+    // Ensure subscription is OneOff
+    await accountsRepository.updateAccount(
+      subscription.id,
+      AccountModel.OneOff,
+      subscription.uploadLimit,
+      subscription.downloadLimit,
+    )
+
+    const before = await AccountsUseCases.getAccountById(subscription.id)
+    if (!before) throw new Error('Subscription not found')
+
+    const creditsToAdd = 123
+    const result = await AccountsUseCases.addCreditsToAccount(
+      mockUser.publicId,
+      creditsToAdd,
+    )
+
+    expect(result.isOk()).toBe(true)
+
+    const after = await AccountsUseCases.getAccountById(subscription.id)
+    if (!after) throw new Error('Subscription not found')
+
+    expect(after.uploadLimit - before.uploadLimit).toBe(creditsToAdd)
+    expect(after.model).toBe(AccountModel.OneOff)
+  })
+
+  it('should fail to add credits if subscription is not OneOff', async () => {
+    jest.spyOn(AuthManager, 'getUserFromPublicId').mockResolvedValue(mockUser)
+    const subscription = await AccountsUseCases.getOrCreateAccount(mockUser)
+    await accountsRepository.updateAccount(
+      subscription.id,
+      AccountModel.Monthly,
+      subscription.uploadLimit,
+      subscription.downloadLimit,
+    )
+
+    const result = await AccountsUseCases.addCreditsToAccount(
+      mockUser.publicId,
+      10,
+    )
+
+    expect(result.isErr()).toBe(true)
+  })
 })
@@ -0,0 +1,232 @@
+import { jest } from '@jest/globals'
+import { IntentsUseCases } from '../../../src/core/users/intents.js'
+import { intentsRepository } from '../../../src/infrastructure/repositories/users/intents.js'
+import { EventRouter } from '../../../src/infrastructure/eventRouter/index.js'
+import { AccountsUseCases } from '../../../src/core/users/accounts.js'
+import { ForbiddenError } from '../../../src/errors/index.js'
+import { IntentStatus, type Intent, type User } from '@auto-drive/models'
+import { ok } from 'neverthrow'
+
+describe('IntentsUseCases', () => {
+  const now = new Date()
+  const user: User = {
+    id: 'user-id',
+    publicId: 'pub-1',
+    walletAddress: '0xabc',
+    createdAt: now,
+    updatedAt: now,
+    authProvider: 'github',
+  } as unknown as User
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.spyOn(IntentsUseCases, 'getPrice').mockResolvedValue({ price: 1 })
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  it('createIntent should create PENDING intent for user', async () => {
+    jest
+      .spyOn(intentsRepository, 'createIntent')
+      .mockImplementation(async (intent) => intent)
+
+    const intent = await IntentsUseCases.createIntent(user)
+
+    expect(intent.userPublicId).toBe(user.publicId)
+    expect(intent.status).toBe(IntentStatus.PENDING)
+    expect(intent.shannonsPerByte).toBe(1n)
+  })
+
+  it('getIntent should return ok when found', async () => {
+    const intent: Intent = {
+      id: '0x1',
+      userPublicId: user.publicId,
+      status: IntentStatus.PENDING,
+      shannonsPerByte: 1n,
+    }
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(intent)
+
+    const result = await IntentsUseCases.getIntent(user, intent.id)
+    expect(result.isOk()).toBe(true)
+    expect(result._unsafeUnwrap().id).toBe(intent.id)
+  })
+
+  it('getIntent should error when not found', async () => {
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(null)
+    const result = await IntentsUseCases.getIntent(user, '0xnope')
+    expect(result.isErr()).toBe(true)
+  })
+
+  it('triggerWatchIntent should publish event and set txHash when user matches', async () => {
+    const intent: Intent = {
+      id: '0x2',
+      userPublicId: user.publicId,
+      status: IntentStatus.PENDING,
+      shannonsPerByte: 1n,
+    }
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(intent)
+    const updateSpy = jest
+      .spyOn(intentsRepository, 'updateIntent')
+      .mockResolvedValue({ ...intent, txHash: '0xhash' })
+    const publishSpy = jest
+      .spyOn(EventRouter, 'publish')
+      .mockImplementation(() => Promise.resolve())
+
+    const res = await IntentsUseCases.triggerWatchIntent({
+      executor: user,
+      txHash: '0xhash',
+      intentId: intent.id,
+    })
+
+    expect(res.isOk()).toBe(true)
+    expect(publishSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'watch-intent-tx' }),
+    )
+    expect(updateSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ id: intent.id, txHash: '0xhash' }),
+    )
+  })
+
+  it('triggerWatchIntent should forbid when user mismatches', async () => {
+    const intent: Intent = {
+      id: '0x3',
+      userPublicId: 'other',
+      status: IntentStatus.PENDING,
+      shannonsPerByte: 1n,
+    }
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(intent)
+
+    const res = await IntentsUseCases.triggerWatchIntent({
+      executor: user,
+      txHash: '0xhash',
+      intentId: intent.id,
+    })
+
+    expect(res.isErr()).toBe(true)
+    expect(res._unsafeUnwrapErr()).toBeInstanceOf(ForbiddenError)
+  })
+
+  it('markIntentAsConfirmed should set status CONFIRMED and deposit amount', async () => {
+    const intent: Intent = {
+      id: '0x4',
+      userPublicId: user.publicId,
+      status: IntentStatus.PENDING,
+      shannonsPerByte: 1n,
+    }
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(intent)
+    const updateSpy = jest
+      .spyOn(intentsRepository, 'updateIntent')
+      .mockResolvedValue({
+        ...intent,
+        status: IntentStatus.CONFIRMED,
+        paymentAmount: 10n,
+      })
+
+    const res = await IntentsUseCases.markIntentAsConfirmed({
+      intentId: intent.id,
+      paymentAmount: 10n,
+    })
+
+    expect(res.isOk()).toBe(true)
+    expect(updateSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: intent.id,
+        status: IntentStatus.CONFIRMED,
+        paymentAmount: 10n,
+      }),
+    )
+  })
+
+  it('onConfirmedIntent should add credits and complete intent', async () => {
+    const paymentAmount = 123n * 10n ** 12n // yields 123 credits when pricePerMB=1
+    const intent: Intent = {
+      id: '0x5',
+      userPublicId: user.publicId,
+      status: IntentStatus.CONFIRMED,
+      paymentAmount,
+      shannonsPerByte: 1n,
+    }
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(intent)
+    const addCreditsSpy = jest
+      .spyOn(AccountsUseCases, 'addCreditsToAccount')
+      .mockResolvedValue(ok())
+    const updateSpy = jest
+      .spyOn(intentsRepository, 'updateIntent')
+      .mockResolvedValue({ ...intent, status: IntentStatus.COMPLETED })
+
+    const res = await IntentsUseCases.onConfirmedIntent(intent.id)
+
+    const credits = Number(paymentAmount / intent.shannonsPerByte)
+
+    expect(res.isOk()).toBe(true)
+    expect(addCreditsSpy).toHaveBeenCalledWith(user.publicId, credits)
+    expect(updateSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: intent.id,
+        status: IntentStatus.COMPLETED,
+      }),
+    )
+  })
+
+  it('onConfirmedIntent should use intent.pricePerMB, not current config', async () => {
+    const storedPrice = 2n
+    // Choose deposit so that credits = 123 when divided by storedPrice
+    const paymentAmount = 123n * BigInt(storedPrice) * 10n ** 12n
+    const intent: Intent = {
+      id: '0x8',
+      userPublicId: user.publicId,
+      status: IntentStatus.CONFIRMED,
+      paymentAmount,
+      shannonsPerByte: storedPrice,
+    }
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(intent)
+    const addCreditsSpy = jest
+      .spyOn(AccountsUseCases, 'addCreditsToAccount')
+      .mockResolvedValue(ok())
+    const updateSpy = jest
+      .spyOn(intentsRepository, 'updateIntent')
+      .mockResolvedValue({ ...intent, status: IntentStatus.COMPLETED })
+
+    const res = await IntentsUseCases.onConfirmedIntent(intent.id)
+
+    expect(res.isOk()).toBe(true)
+    const credits = Number(paymentAmount / intent.shannonsPerByte)
+    expect(addCreditsSpy).toHaveBeenCalledWith(user.publicId, credits)
+    expect(updateSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: intent.id,
+        status: IntentStatus.COMPLETED,
+      }),
+    )
+  })
+
+  it('onConfirmedIntent should error when already completed', async () => {
+    const intent: Intent = {
+      id: '0x6',
+      userPublicId: user.publicId,
+      status: IntentStatus.COMPLETED,
+      paymentAmount: 1n,
+      shannonsPerByte: 1n,
+    }
+    jest.spyOn(intentsRepository, 'getById').mockResolvedValue(intent)
+
+    const res = await IntentsUseCases.onConfirmedIntent(intent.id)
+    expect(res.isErr()).toBe(true)
+  })
+
+  it('getConfirmedIntents should proxy repository', async () => {
+    const intents: Intent[] = [
+      {
+        id: '0x7',
+        userPublicId: user.publicId,
+        status: IntentStatus.CONFIRMED,
+        shannonsPerByte: 1n,
+      },
+    ]
+    jest.spyOn(intentsRepository, 'getByStatus').mockResolvedValue(intents)
+    const res = await IntentsUseCases.getConfirmedIntents()
+    expect(res).toEqual(intents)
+  })
+})