diff --git a/backend/src/config/index.test.ts b/backend/src/config/index.test.ts
new file mode 100644
index 000000000..3c4c7865e
--- /dev/null
+++ b/backend/src/config/index.test.ts
@@ -0,0 +1,9 @@
+import CONFIG from './index'
+
+describe('config/index', () => {
+  describe('decay start block', () => {
+    it('has the correct date set', () => {
+      expect(CONFIG.DECAY_START_TIME).toEqual(new Date('2021-05-13 17:46:31'))
+    })
+  })
+})
diff --git a/backend/src/config/index.ts b/backend/src/config/index.ts
index 64f3fd667..0391f41f1 100644
--- a/backend/src/config/index.ts
+++ b/backend/src/config/index.ts
@@ -4,7 +4,8 @@ import dotenv from 'dotenv'
 dotenv.config()
 
 const constants = {
-  DB_VERSION: '0021-elopagebuys_fields_nullable',
+  DB_VERSION: '0022-delete_decay_start_block',
+  DECAY_START_TIME: new Date('2021-05-13 17:46:31'), // GMT+0
 }
 
 const server = {
diff --git a/backend/src/graphql/model/Decay.ts b/backend/src/graphql/model/Decay.ts
index 48ed7b8c5..a09f7c97e 100644
--- a/backend/src/graphql/model/Decay.ts
+++ b/backend/src/graphql/model/Decay.ts
@@ -4,7 +4,7 @@ import { ObjectType, Field, Int } from 'type-graphql'
 
 @ObjectType()
 export class Decay {
-  constructor(json: any) {
+  constructor(json?: any) {
     if (json) {
       this.balance = Number(json.balance)
       this.decayStart = json.decay_start
diff --git a/backend/src/graphql/resolver/AdminResolver.ts b/backend/src/graphql/resolver/AdminResolver.ts
index 4da51398c..c314b5bb7 100644
--- a/backend/src/graphql/resolver/AdminResolver.ts
+++ b/backend/src/graphql/resolver/AdminResolver.ts
@@ -237,11 +237,11 @@ export class AdminResolver {
     if (!lastUserTransaction) {
       newBalance = 0
     } else {
-      newBalance = await calculateDecay(
+      newBalance = calculateDecay(
         lastUserTransaction.balance,
         lastUserTransaction.balanceDate,
         receivedCallDate,
-      )
+      ).balance
     }
     newBalance = Number(newBalance) + Number(parseInt(pendingCreation.amount.toString()))
 
diff --git a/backend/src/graphql/resolver/BalanceResolver.ts b/backend/src/graphql/resolver/BalanceResolver.ts
index dd7280657..0ecfbb7cd 100644
--- a/backend/src/graphql/resolver/BalanceResolver.ts
+++ b/backend/src/graphql/resolver/BalanceResolver.ts
@@ -35,7 +35,7 @@ export class BalanceResolver {
     return new Balance({
       balance: roundFloorFrom4(balanceEntity.amount),
       decay: roundFloorFrom4(
-        await calculateDecay(balanceEntity.amount, balanceEntity.recordDate, now),
+        calculateDecay(balanceEntity.amount, balanceEntity.recordDate, now).balance,
       ),
       decay_date: now.toString(),
     })
diff --git a/backend/src/graphql/resolver/TransactionResolver.ts b/backend/src/graphql/resolver/TransactionResolver.ts
index 4e40a35c2..6eac816a8 100644
--- a/backend/src/graphql/resolver/TransactionResolver.ts
+++ b/backend/src/graphql/resolver/TransactionResolver.ts
@@ -29,7 +29,7 @@ import { Balance as dbBalance } from '@entity/Balance'
 
 import { apiPost } from '../../apis/HttpRequest'
 import { roundFloorFrom4, roundCeilFrom4 } from '../../util/round'
-import { calculateDecay, calculateDecayWithInterval } from '../../util/decay'
+import { calculateDecay } from '../../util/decay'
 import { TransactionTypeId } from '../enum/TransactionTypeId'
 import { TransactionType } from '../enum/TransactionType'
 import { hasUserAmount, isHexPublicKey } from '../../util/validate'
@@ -67,8 +67,6 @@ async function calculateAndAddDecayTransactions(
   const userRepository = getCustomRepository(UserRepository)
   const userIndiced = await userRepository.getUsersIndiced(involvedUsersUnique)
 
-  const decayStartTransaction = await transactionRepository.findDecayStartBlock()
-
   for (let i = 0; i < userTransactions.length; i++) {
     const userTransaction = userTransactions[i]
     const transaction = transactionIndiced[userTransaction.transactionId]
@@ -81,26 +79,22 @@ async function calculateAndAddDecayTransactions(
 
     if (previousTransaction) {
       const currentTransaction = userTransaction
-      const decay = await calculateDecayWithInterval(
+      const decay = calculateDecay(
         previousTransaction.balance,
         previousTransaction.balanceDate,
         currentTransaction.balanceDate,
       )
       const balance = previousTransaction.balance - decay.balance
 
-      if (
-        decayStartTransaction &&
-        decayStartTransaction.received < currentTransaction.balanceDate
-      ) {
+      if (CONFIG.DECAY_START_TIME < currentTransaction.balanceDate) {
         finalTransaction.decay = decay
         finalTransaction.decay.balance = roundFloorFrom4(balance)
         if (
-          decayStartTransaction &&
-          previousTransaction.transactionId < decayStartTransaction.id &&
-          currentTransaction.transactionId > decayStartTransaction.id
+          previousTransaction.balanceDate < CONFIG.DECAY_START_TIME &&
+          currentTransaction.balanceDate > CONFIG.DECAY_START_TIME
         ) {
           finalTransaction.decay.decayStartBlock = (
-            decayStartTransaction.received.getTime() / 1000
+            CONFIG.DECAY_START_TIME.getTime() / 1000
           ).toString()
         }
       }
@@ -147,11 +141,7 @@ async function calculateAndAddDecayTransactions(
 
     if (i === userTransactions.length - 1 && decay) {
       const now = new Date()
-      const decay = await calculateDecayWithInterval(
-        userTransaction.balance,
-        userTransaction.balanceDate,
-        now.getTime(),
-      )
+      const decay = calculateDecay(userTransaction.balance, userTransaction.balanceDate, now)
       const balance = userTransaction.balance - decay.balance
 
       const decayTransaction = new Transaction()
@@ -233,12 +223,8 @@ async function updateStateBalance(
     balance.amount = centAmount
     balance.modified = received
   } else {
-    const decaiedBalance = await calculateDecay(balance.amount, balance.recordDate, received).catch(
-      () => {
-        throw new Error('error by calculating decay')
-      },
-    )
-    balance.amount = Number(decaiedBalance) + centAmount
+    const decayedBalance = calculateDecay(balance.amount, balance.recordDate, received).balance
+    balance.amount = Number(decayedBalance) + centAmount
     balance.modified = new Date()
   }
   if (balance.amount <= 0) {
@@ -262,13 +248,11 @@ async function addUserTransaction(
   const lastUserTransaction = await userTransactionRepository.findLastForUser(user.id)
   if (lastUserTransaction) {
     newBalance += Number(
-      await calculateDecay(
+      calculateDecay(
         Number(lastUserTransaction.balance),
         lastUserTransaction.balanceDate,
         transaction.received,
-      ).catch(() => {
-        throw new Error('error by calculating decay')
-      }),
+      ).balance,
     )
   }
 
@@ -346,7 +330,7 @@ export class TransactionResolver {
       const now = new Date()
       transactions.balance = roundFloorFrom4(balanceEntity.amount)
       transactions.decay = roundFloorFrom4(
-        await calculateDecay(balanceEntity.amount, balanceEntity.recordDate, now),
+        calculateDecay(balanceEntity.amount, balanceEntity.recordDate, now).balance,
       )
       transactions.decayDate = now.toString()
     }
diff --git a/backend/src/typeorm/repository/Transaction.ts b/backend/src/typeorm/repository/Transaction.ts
index ab09b2731..0a97067a2 100644
--- a/backend/src/typeorm/repository/Transaction.ts
+++ b/backend/src/typeorm/repository/Transaction.ts
@@ -3,13 +3,6 @@ import { Transaction } from '@entity/Transaction'
 
 @EntityRepository(Transaction)
 export class TransactionRepository extends Repository<Transaction> {
-  async findDecayStartBlock(): Promise<Transaction | undefined> {
-    return this.createQueryBuilder('transaction')
-      .where('transaction.transactionTypeId = :transactionTypeId', { transactionTypeId: 9 })
-      .orderBy('received', 'ASC')
-      .getOne()
-  }
-
   async joinFullTransactionsByIds(transactionIds: number[]): Promise<Transaction[]> {
     return this.createQueryBuilder('transaction')
       .where('transaction.id IN (:...transactions)', { transactions: transactionIds })
diff --git a/backend/src/util/decay.test.ts b/backend/src/util/decay.test.ts
index e34d8b58b..2db9411b5 100644
--- a/backend/src/util/decay.test.ts
+++ b/backend/src/util/decay.test.ts
@@ -1,3 +1,4 @@
+import 'reflect-metadata' // This might be wise to load in a test setup file
 import { decayFormula, calculateDecay } from './decay'
 
 describe('utils/decay', () => {
@@ -35,6 +36,6 @@ describe('utils/decay', () => {
 
   it('returns input amount when from and to is the same', async () => {
     const now = new Date()
-    expect(await calculateDecay(100.0, now, now)).toBe(100.0)
+    expect((await calculateDecay(100.0, now, now)).balance).toBe(100.0)
   })
 })
diff --git a/backend/src/util/decay.ts b/backend/src/util/decay.ts
index 63cf9541d..7cb4ce384 100644
--- a/backend/src/util/decay.ts
+++ b/backend/src/util/decay.ts
@@ -1,70 +1,46 @@
-import { getCustomRepository } from '@dbTools/typeorm'
+import CONFIG from '../config'
 import { Decay } from '../graphql/model/Decay'
-import { TransactionRepository } from '../typeorm/repository/Transaction'
 
 function decayFormula(amount: number, seconds: number): number {
   return amount * Math.pow(0.99999997802044727, seconds) // This number represents 50% decay a year
 }
 
-async function calculateDecay(amount: number, from: Date, to: Date): Promise<number> {
-  if (amount === undefined || !from || !to) {
-    throw new Error('at least one parameter is undefined')
+function calculateDecay(amount: number, from: Date, to: Date): Decay {
+  const fromMs = from.getTime()
+  const toMs = to.getTime()
+  const decayStartBlockMs = CONFIG.DECAY_START_TIME.getTime()
+
+  if (toMs < fromMs) {
+    throw new Error('to < from, reverse decay calculation is invalid')
   }
-  if (from === to) {
-    return amount
+
+  // Initialize with no decay
+  const decay = new Decay({
+    balance: amount,
+    decayStart: null,
+    decayEnd: null,
+    decayDuration: 0,
+    decayStartBlock: (decayStartBlockMs / 1000).toString(),
+  })
+
+  // decay started after end date; no decay
+  if (decayStartBlockMs > toMs) {
+    return decay
   }
-  if (to < from) {
-    throw new Error('to < from, so the target date is in the past?')
+  // decay started before start date; decay for full duration
+  else if (decayStartBlockMs < fromMs) {
+    decay.decayStart = (fromMs / 1000).toString()
+    decay.decayDuration = (toMs - fromMs) / 1000
   }
-  // load decay start block
-  const transactionRepository = getCustomRepository(TransactionRepository)
-  const decayStartBlock = await transactionRepository.findDecayStartBlock()
-
-  // if decay hasn't started yet we return input amount
-  if (!decayStartBlock) return amount
-
-  // what happens when from > to
-  // Do we want to have negative decay?
-  const decayDuration = (to.getTime() - from.getTime()) / 1000
-  return decayFormula(amount, decayDuration)
-}
-
-async function calculateDecayWithInterval(
-  amount: number,
-  from: number | Date,
-  to: number | Date,
-): Promise<Decay> {
-  const transactionRepository = getCustomRepository(TransactionRepository)
-  const decayStartBlock = await transactionRepository.findDecayStartBlock()
-
-  const result = new Decay(undefined)
-  result.balance = amount
-  const fromMillis = typeof from === 'number' ? from : from.getTime()
-  const toMillis = typeof to === 'number' ? to : to.getTime()
-  result.decayStart = (fromMillis / 1000).toString()
-  result.decayEnd = (toMillis / 1000).toString()
-
-  // (amount, from.getTime(), to.getTime())
-
-  // if no decay start block exist or decay startet after end date
-  if (!decayStartBlock || decayStartBlock.received.getTime() > toMillis) {
-    return result
-  }
-  const decayStartBlockMillis = decayStartBlock.received.getTime()
-
-  // if decay start date is before start date we calculate decay for full duration
-  if (decayStartBlockMillis < fromMillis) {
-    result.decayDuration = toMillis - fromMillis
-  }
-  // if decay start in between start date and end date we caculcate decay from decay start time to end date
+  // decay started between start and end date; decay from decay start till end date
   else {
-    result.decayDuration = toMillis - decayStartBlockMillis
-    result.decayStart = (decayStartBlockMillis / 1000).toString()
+    decay.decayStart = (decayStartBlockMs / 1000).toString()
+    decay.decayDuration = (toMs - decayStartBlockMs) / 1000
   }
-  // js use timestamp in milliseconds but we calculate with seconds
-  result.decayDuration /= 1000
-  result.balance = decayFormula(amount, result.decayDuration)
-  return result
+
+  decay.decayEnd = (toMs / 1000).toString()
+  decay.balance = decayFormula(amount, decay.decayDuration)
+  return decay
 }
 
-export { decayFormula, calculateDecay, calculateDecayWithInterval }
+export { decayFormula, calculateDecay }
diff --git a/backend/src/util/validate.ts b/backend/src/util/validate.ts
index b94550d63..edd663e9e 100644
--- a/backend/src/util/validate.ts
+++ b/backend/src/util/validate.ts
@@ -21,7 +21,7 @@ async function hasUserAmount(user: dbUser, amount: number): Promise<boolean> {
   const balance = await balanceRepository.findOne({ userId: user.id })
   if (!balance) return false
 
-  const decay = await calculateDecay(balance.amount, balance.recordDate, new Date())
+  const decay = calculateDecay(balance.amount, balance.recordDate, new Date()).balance
   return decay > amount
 }
 
diff --git a/database/migrations/0022-delete_decay_start_block.ts b/database/migrations/0022-delete_decay_start_block.ts
new file mode 100644
index 000000000..22027933e
--- /dev/null
+++ b/database/migrations/0022-delete_decay_start_block.ts
@@ -0,0 +1,18 @@
+/* MIGRATION TO DELETE DECAY START BLOCK
+ *
+ * the decay start block is now specified as static value
+ * we can delete it from the database
+ */
+
+export async function upgrade(queryFn: (query: string, values?: any[]) => Promise<Array<any>>) {
+  // Remove transactions with type 9 (start decay block). This should affect exactly 1 row
+  await queryFn(`DELETE FROM transactions WHERE transaction_type_id = 9;`)
+}
+
+export async function downgrade(queryFn: (query: string, values?: any[]) => Promise<Array<any>>) {
+  // When rolling back an empty database this entry is newly created. This should not hurt in any way tho.
+  await queryFn(`
+    INSERT INTO transactions
+    VALUES(1682,9,0xC27BE999D7B4704E5F294099E780C5D6A275B165AFABFD8BECCEA39059CBB7B600000000000000000000000000000000,'','2021-05-13 15:46:31',NULL,NULL)
+  `)
+}
diff --git a/database/src/index.ts b/database/src/index.ts
index fefdea217..4ae3d21b6 100644
--- a/database/src/index.ts
+++ b/database/src/index.ts
@@ -8,7 +8,6 @@ import { CreateRaeuberHotzenplotzSeed } from './seeds/users/raeuber-hotzenplotz.
 import { CreateBobBaumeisterSeed } from './seeds/users/bob-baumeister.seed'
 import { CreateGarrickOllivanderSeed } from './seeds/users/garrick-ollivander.seed'
 import { CreateUserSeed } from './seeds/create-user.seed'
-import { DecayStartBlockSeed } from './seeds/decay-start-block.seed'
 import { resetDB, pool, migration } from './helpers'
 
 const run = async (command: string) => {
@@ -41,7 +40,6 @@ const run = async (command: string) => {
         root: process.cwd(),
         configName: 'ormconfig.js',
       })
-      await runSeeder(DecayStartBlockSeed)
       await runSeeder(CreatePeterLustigSeed)
       await runSeeder(CreateBibiBloxbergSeed)
       await runSeeder(CreateRaeuberHotzenplotzSeed)
diff --git a/database/src/seeds/decay-start-block.seed.ts b/database/src/seeds/decay-start-block.seed.ts
deleted file mode 100644
index fd62ee333..000000000
--- a/database/src/seeds/decay-start-block.seed.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { Factory, Seeder } from 'typeorm-seeding'
-import { Transaction } from '../../entity/Transaction'
-
-export class DecayStartBlockSeed implements Seeder {
-  public async run(factory: Factory): Promise<void> {
-    await factory(Transaction)({
-      transactionTypeId: 9,
-      txHash: Buffer.from(
-        '9c9c4152b8a4cfbac287eee18d2d262e9de756fae726fc0ca36b788564973fff00000000000000000000000000000000',
-        'hex',
-      ),
-      memo: '',
-      received: new Date('2021-11-30T09:13:26'),
-      blockchainTypeId: 1,
-    }).create()
-  }
-}