Merge pull request #177 from andrewdwallo/refactor/multicurrency-handling

Refactor/multicurrency handling

app/Casts/DocumentMoneyCast.php

-<?php
-
-namespace App\Casts;
-
-use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
-use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
-use Illuminate\Database\Eloquent\Model;
-use UnexpectedValueException;
-
-class DocumentMoneyCast implements CastsAttributes
-{
-    /**
-     * Cast the given value.
-     *
-     * @param  array<string, mixed>  $attributes
-     */
-    public function get(Model $model, string $key, mixed $value, array $attributes): mixed
-    {
-        $currency_code = $attributes['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
-
-        if ($value !== null) {
-            return CurrencyConverter::convertCentsToFloat($value, $currency_code);
-        }
-
-        return 0.0;
-    }
-
-    /**
-     * Prepare the given value for storage.
-     *
-     * @param  array<string, mixed>  $attributes
-     */
-    public function set(Model $model, string $key, mixed $value, array $attributes): mixed
-    {
-        if (is_numeric($value)) {
-            $value = (string) $value;
-        } elseif (! is_string($value)) {
-            throw new UnexpectedValueException('Expected string or numeric value for money cast');
-        }
-
-        return CurrencyConverter::prepareForAccessor($value, 'USD');
-    }
-}

app/Casts/JournalEntryCast.php

-<?php
-
-namespace App\Casts;
-
-use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
-use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
-use Illuminate\Database\Eloquent\Model;
-use UnexpectedValueException;
-
-class JournalEntryCast implements CastsAttributes
-{
-    public function get(Model $model, string $key, mixed $value, array $attributes): string
-    {
-        $currency_code = CurrencyAccessor::getDefaultCurrency();
-
-        if ($value !== null) {
-            return CurrencyConverter::prepareForMutator($value, $currency_code);
-        }
-
-        return '';
-    }
-
-    /**
-     * @throws UnexpectedValueException
-     */
-    public function set(Model $model, string $key, mixed $value, array $attributes): int
-    {
-        $currency_code = CurrencyAccessor::getDefaultCurrency();
-
-        if (is_numeric($value)) {
-            $value = (string) $value;
-        } elseif (! is_string($value)) {
-            throw new UnexpectedValueException('Expected string or numeric value for money cast');
-        }
-
-        return CurrencyConverter::prepareForAccessor($value, $currency_code);
-    }
-}

app/Casts/MoneyCast.php

 
 namespace App\Casts;
 
-use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
 use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
 use Illuminate\Database\Eloquent\Model;
 use UnexpectedValueException;
 
 class MoneyCast implements CastsAttributes
 {
-    public function get(Model $model, string $key, mixed $value, array $attributes): string
+    public function get(Model $model, string $key, mixed $value, array $attributes): int
     {
-        $currency_code = $attributes['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
-
-        if ($value !== null) {
-            return CurrencyConverter::prepareForMutator($value, $currency_code);
-        }
-
-        return '';
+        return (int) $value;
     }
 
     /**
      */
     public function set(Model $model, string $key, mixed $value, array $attributes): int
     {
-        $currency_code = $attributes['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
-
-        if (is_numeric($value)) {
-            $value = (string) $value;
-        } elseif (! is_string($value)) {
-            throw new UnexpectedValueException('Expected string or numeric value for money cast');
-        }
-
-        return CurrencyConverter::prepareForAccessor($value, $currency_code);
+        return (int) $value;
     }
 }

app/Casts/RateCast.php

             return '0';
         }
 
-        $currency_code = $this->getDefaultCurrencyCode();
+        $currencyCode = $attributes['currency_code'] ?? $this->getDefaultCurrencyCode();
         $computation = AdjustmentComputation::parse($attributes['computation'] ?? $attributes['discount_computation'] ?? null);
 
         if ($computation?->isFixed()) {
-            return money($value, $currency_code)->formatSimple();
+            return money($value, $currencyCode)->formatSimple();
         }
 
         return RateCalculator::formatScaledRate($value);
 
         $computation = AdjustmentComputation::parse($attributes['computation'] ?? $attributes['discount_computation'] ?? null);
 
-        $currency_code = $this->getDefaultCurrencyCode();
+        $currencyCode = $attributes['currency_code'] ?? $this->getDefaultCurrencyCode();
 
         if ($computation?->isFixed()) {
-            return money($value, $currency_code, true)->getAmount();
+            return money($value, $currencyCode, true)->getAmount();
         }
 
         return RateCalculator::parseLocalizedRate($value);

app/Casts/TransactionAmountCast.php

-<?php
-
-namespace App\Casts;
-
-use App\Models\Banking\BankAccount;
-use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
-use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
-use Illuminate\Database\Eloquent\Model;
-use UnexpectedValueException;
-
-class TransactionAmountCast implements CastsAttributes
-{
-    /**
-     * Static cache to persist across instances
-     */
-    private static array $currencyCache = [];
-
-    /**
-     * Eagerly load all required bank accounts at once if needed
-     */
-    private function loadMissingBankAccounts(array $ids): void
-    {
-        $missingIds = array_filter($ids, static fn ($id) => ! isset(self::$currencyCache[$id]) && $id !== null);
-
-        if (empty($missingIds)) {
-            return;
-        }
-
-        /** @var BankAccount[] $accounts */
-        $accounts = BankAccount::with('account')
-            ->whereIn('id', $missingIds)
-            ->get();
-
-        foreach ($accounts as $account) {
-            self::$currencyCache[$account->id] = $account->account->currency_code ?? CurrencyAccessor::getDefaultCurrency();
-        }
-    }
-
-    public function get(Model $model, string $key, mixed $value, array $attributes): string
-    {
-        // Attempt to retrieve the currency code from the related bankAccount->account model
-        $bankAccountId = $attributes['bank_account_id'] ?? null;
-
-        if ($bankAccountId !== null && ! isset(self::$currencyCache[$bankAccountId])) {
-            $this->loadMissingBankAccounts([$bankAccountId]);
-        }
-
-        $currencyCode = $this->getCurrencyCodeFromBankAccountId($bankAccountId);
-
-        if ($value !== null) {
-            return CurrencyConverter::prepareForMutator($value, $currencyCode);
-        }
-
-        return '';
-    }
-
-    /**
-     * @throws UnexpectedValueException
-     */
-    public function set(Model $model, string $key, mixed $value, array $attributes): int
-    {
-        $bankAccountId = $attributes['bank_account_id'] ?? null;
-
-        if ($bankAccountId !== null && ! isset(self::$currencyCache[$bankAccountId])) {
-            $this->loadMissingBankAccounts([$bankAccountId]);
-        }
-
-        $currencyCode = $this->getCurrencyCodeFromBankAccountId($bankAccountId);
-
-        if (is_numeric($value)) {
-            $value = (string) $value;
-        } elseif (! is_string($value)) {
-            throw new UnexpectedValueException('Expected string or numeric value for money cast');
-        }
-
-        return CurrencyConverter::prepareForAccessor($value, $currencyCode);
-    }
-
-    /**
-     * Get currency code from the cache or use default
-     */
-    private function getCurrencyCodeFromBankAccountId(?int $bankAccountId): string
-    {
-        if ($bankAccountId === null) {
-            return CurrencyAccessor::getDefaultCurrency();
-        }
-
-        return self::$currencyCache[$bankAccountId] ?? CurrencyAccessor::getDefaultCurrency();
-    }
-}

app/Casts/TrimLeadingZeroCast.php

-<?php
-
-namespace App\Casts;
-
-use Illuminate\Contracts\Database\Eloquent\CastsInboundAttributes;
-use Illuminate\Database\Eloquent\Model;
-
-class TrimLeadingZeroCast implements CastsInboundAttributes
-{
-    public function set(Model $model, string $key, mixed $value, array $attributes): int
-    {
-        return (int) ltrim($value, '0');
-    }
-}

app/Collections/Accounting/JournalEntryCollection.php

 
 use App\Models\Accounting\JournalEntry;
 use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
 use App\ValueObjects\Money;
 use Illuminate\Database\Eloquent\Collection;
 
     {
         $total = $this->reduce(static function ($carry, JournalEntry $item) {
             if ($item->type->isDebit()) {
-                $amountAsInteger = CurrencyConverter::convertToCents($item->amount);
+                $amountAsInteger = $item->amount;
 
                 return bcadd($carry, $amountAsInteger, 0);
             }
     {
         $total = $this->reduce(static function ($carry, JournalEntry $item) {
             if ($item->type->isCredit()) {
-                $amountAsInteger = CurrencyConverter::convertToCents($item->amount);
+                $amountAsInteger = $item->amount;
 
                 return bcadd($carry, $amountAsInteger, 0);
             }

app/Concerns/HasTransactionAction.php

 use App\Models\Accounting\Transaction;
 use App\Models\Banking\BankAccount;
 use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
 use Awcodes\TableRepeater\Header;
 use Closure;
 use Filament\Forms;
                     ->options(fn (?Transaction $transaction) => Transaction::getBankAccountOptions(currentBankAccountId: $transaction?->bank_account_id))
                     ->live()
                     ->searchable()
-                    ->afterStateUpdated(function (Forms\Set $set, $state, $old, Forms\Get $get) {
-                        $amount = CurrencyConverter::convertAndSet(
-                            BankAccount::find($state)->account->currency_code,
-                            BankAccount::find($old)->account->currency_code ?? CurrencyAccessor::getDefaultCurrency(),
-                            $get('amount')
-                        );
-
-                        if ($amount !== null) {
-                            $set('amount', $amount);
-                        }
-                    })
                     ->required(),
                 Forms\Components\Select::make('type')
                     ->label('Type')
                     ->options(fn (Forms\Get $get, ?Transaction $transaction) => Transaction::getBankAccountOptions(excludedAccountId: $get('account_id'), currentBankAccountId: $transaction?->bank_account_id))
                     ->live()
                     ->searchable()
-                    ->afterStateUpdated(function (Forms\Set $set, $state, $old, Forms\Get $get) {
-                        $amount = CurrencyConverter::convertAndSet(
-                            BankAccount::find($state)->account->currency_code,
-                            BankAccount::find($old)->account->currency_code ?? CurrencyAccessor::getDefaultCurrency(),
-                            $get('amount')
-                        );
-
-                        if ($amount !== null) {
-                            $set('amount', $amount);
-                        }
-                    })
                     ->required(),
                 Forms\Components\Select::make('type')
                     ->label('Type')
             Forms\Components\TextInput::make('amount')
                 ->label('Amount')
                 ->live()
-                ->mask(moneyMask(CurrencyAccessor::getDefaultCurrency()))
+                ->money()
                 ->afterStateUpdated(function (Forms\Get $get, Forms\Set $set, ?string $state, ?string $old) {
                     $this->updateJournalEntryAmount(JournalEntryType::parse($get('type')), $state, $old);
                 })

app/Concerns/ManagesLineItems.php

         $grandTotalCents = $subtotalCents + $taxTotalCents - $discountTotalCents;
 
         return [
-            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents, $currencyCode),
-            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents, $currencyCode),
-            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents, $currencyCode),
-            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents, $currencyCode),
+            'subtotal' => $subtotalCents,
+            'tax_total' => $taxTotalCents,
+            'discount_total' => $discountTotalCents,
+            'total' => $grandTotalCents,
         ];
     }
 

app/DTO/DocumentDTO.php

         );
     }
 
-    protected static function formatToMoney(float | string $value, ?string $currencyCode): string
+    protected static function formatToMoney(int $value, ?string $currencyCode): string
     {
-        return CurrencyConverter::formatToMoney($value, $currencyCode);
+        return CurrencyConverter::formatCentsToMoney($value, $currencyCode);
     }
 
     public function getFontHtml(): Htmlable

app/DTO/DocumentPreviewDTO.php

         $paymentTerms = PaymentTerms::parse($data['payment_terms']) ?? $settings->payment_terms;
 
         $amountDue = $settings->type !== DocumentType::Estimate ?
-            self::formatToMoney('950', null) :
+            self::formatToMoney(95000, null) :
             null;
 
         return new self(
             date: $company->locale->date_format->getLabel(),
             dueDate: $paymentTerms->getDueDate($company->locale->date_format->value),
             currencyCode: CurrencyAccessor::getDefaultCurrency(),
-            subtotal: self::formatToMoney('1000', null),
-            discount: self::formatToMoney('100', null),
-            tax: self::formatToMoney('50', null),
-            total: self::formatToMoney('950', null),
-            amountDue: $amountDue,
+            subtotal: self::formatToMoney(100000, null), // $1000.00
+            discount: self::formatToMoney(10000, null), // $100.00
+            tax: self::formatToMoney(5000, null), // $50.00
+            total: self::formatToMoney(95000, null), // $950.00
+            amountDue: $amountDue, // $950.00 or null for estimates
             company: CompanyDTO::fromModel($company),
             client: ClientPreviewDTO::fake(),
             lineItems: LineItemPreviewDTO::fakeItems(),

app/DTO/LineItemDTO.php

         );
     }
 
-    protected static function formatToMoney(float | string $value, ?string $currencyCode): string
+    protected static function formatToMoney(float | string | int $value, ?string $currencyCode): string
     {
+        if (is_int($value)) {
+            return CurrencyConverter::formatCentsToMoney($value, $currencyCode);
+        }
+
         return CurrencyConverter::formatToMoney($value, $currencyCode);
     }
 }

app/DTO/LineItemPreviewDTO.php

     {
         return [
             new self(
-                name: 'Item 1',
-                description: 'Sample item description',
+                name: 'Professional Services',
+                description: 'Consulting and strategic planning',
                 quantity: 2,
-                unitPrice: self::formatToMoney(150.00, null),
-                subtotal: self::formatToMoney(300.00, null),
+                unitPrice: self::formatToMoney(15000, null), // $150.00
+                subtotal: self::formatToMoney(30000, null),  // $300.00
             ),
             new self(
-                name: 'Item 2',
-                description: 'Another sample item description',
+                name: 'Software License',
+                description: 'Annual subscription and support',
                 quantity: 3,
-                unitPrice: self::formatToMoney(200.00, null),
-                subtotal: self::formatToMoney(600.00, null),
+                unitPrice: self::formatToMoney(20000, null), // $200.00
+                subtotal: self::formatToMoney(60000, null),  // $600.00
             ),
             new self(
-                name: 'Item 3',
-                description: 'Yet another sample item description',
+                name: 'Training Session',
+                description: 'Team onboarding and documentation',
                 quantity: 1,
-                unitPrice: self::formatToMoney(180.00, null),
-                subtotal: self::formatToMoney(180.00, null),
+                unitPrice: self::formatToMoney(10000, null), // $100.00
+                subtotal: self::formatToMoney(10000, null),  // $100.00
             ),
         ];
     }

app/Filament/Company/Resources/Accounting/TransactionResource.php

 use App\Filament\Forms\Components\DateRangeSelect;
 use App\Filament\Tables\Actions\EditTransactionAction;
 use App\Filament\Tables\Actions\ReplicateBulkAction;
+use App\Filament\Tables\Columns;
 use App\Models\Accounting\JournalEntry;
 use App\Models\Accounting\Transaction;
 use App\Models\Common\Client;
                     });
             })
             ->columns([
+                Columns::id(),
                 Tables\Columns\TextColumn::make('posted_at')
                     ->label('Date')
                     ->sortable()

app/Filament/Company/Resources/Common/OfferingResource.php

 use App\Filament\Forms\Components\CreateAccountSelect;
 use App\Filament\Forms\Components\CreateAdjustmentSelect;
 use App\Models\Common\Offering;
-use App\Utilities\Currency\CurrencyAccessor;
 use Filament\Forms;
 use Filament\Forms\Form;
 use Filament\Resources\Resource;
             ])->columns();
     }
 
-    public static function getSellableSection(bool $showByDefault = false): Forms\Components\Section
+    public static function getSellableSection(): Forms\Components\Section
     {
         return Forms\Components\Section::make('Sale Information')
             ->schema([
                 Tables\Columns\TextColumn::make('type')
                     ->searchable(),
                 Tables\Columns\TextColumn::make('price')
-                    ->currency(CurrencyAccessor::getDefaultCurrency(), true)
+                    ->currency()
                     ->sortable()
                     ->description(function (Offering $record) {
                         $adjustments = $record->adjustments()

app/Filament/Company/Resources/Purchases/BillResource.php

                                         $date = $get('date');
                                         $paymentTerms = $get('payment_terms');
 
-                                        if (! $date || $paymentTerms === 'custom') {
+                                        if (! $date || $paymentTerms === 'custom' || ! $paymentTerms) {
                                             return;
                                         }
 
                                                 return;
                                             }
 
-                                            $unitPrice = CurrencyConverter::convertToFloat($offeringRecord->price, $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency());
+                                            $unitPrice = CurrencyConverter::convertCentsToFormatSimple($offeringRecord->price, 'USD');
 
                                             $set('description', $offeringRecord->description);
                                             $set('unit_price', $unitPrice);
                                     ->maxValue(9999999999.99)
                                     ->default(1),
                                 Forms\Components\TextInput::make('unit_price')
-                                    ->label('Price')
                                     ->hiddenLabel()
-                                    ->numeric()
+                                    ->money(useAffix: false)
                                     ->live()
-                                    ->maxValue(9999999999.99)
                                     ->default(0),
                                 Forms\Components\Group::make([
                                     CreateAdjustmentSelect::make('purchaseTaxes')
                                     ->extraAttributes(['class' => 'text-left sm:text-right'])
                                     ->content(function (Forms\Get $get) {
                                         $quantity = max((float) ($get('quantity') ?? 0), 0);
-                                        $unitPrice = max((float) ($get('unit_price') ?? 0), 0);
+                                        $unitPrice = CurrencyConverter::isValidAmount($get('unit_price'), 'USD')
+                                            ? CurrencyConverter::convertToFloat($get('unit_price'), 'USD')
+                                            : 0;
                                         $purchaseTaxes = $get('purchaseTaxes') ?? [];
                                         $purchaseDiscounts = $get('purchaseDiscounts') ?? [];
                                         $currencyCode = $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency();
                                     ->live(onBlur: true)
                                     ->helperText(function (Bill $record, $state) {
                                         $billCurrency = $record->currency_code;
-                                        if (! CurrencyConverter::isValidAmount($state, $billCurrency)) {
+                                        if (! CurrencyConverter::isValidAmount($state, 'USD')) {
                                             return null;
                                         }
 
-                                        $amountDue = $record->getRawOriginal('amount_due');
-                                        $amount = CurrencyConverter::convertToCents($state, $billCurrency);
+                                        $amountDue = $record->amount_due;
+                                        $amount = CurrencyConverter::convertToCents($state, 'USD');
 
                                         if ($amount <= 0) {
                                             return 'Please enter a valid positive amount';
                                         };
                                     })
                                     ->rules([
-                                        static fn (Bill $record): Closure => static function (string $attribute, $value, Closure $fail) use ($record) {
-                                            if (! CurrencyConverter::isValidAmount($value, $record->currency_code)) {
+                                        static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
+                                            if (! CurrencyConverter::isValidAmount($value, 'USD')) {
                                                 $fail('Please enter a valid amount');
                                             }
                                         },
                             }
                         })
                         ->mountUsing(function (Collection $records, Form $form) {
-                            $totalAmountDue = $records->sum(fn (Bill $bill) => $bill->getRawOriginal('amount_due'));
+                            $totalAmountDue = $records->sum('amount_due');
 
                             $form->fill([
                                 'posted_at' => now(),
-                                'amount' => CurrencyConverter::convertCentsToFormatSimple($totalAmountDue),
+                                'amount' => $totalAmountDue,
                             ]);
                         })
                         ->form([
                                 ->label('Notes'),
                         ])
                         ->before(function (Collection $records, Tables\Actions\BulkAction $action, array $data) {
-                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
-                            $totalAmountDue = $records->sum(fn (Bill $bill) => $bill->getRawOriginal('amount_due'));
+                            $totalPaymentAmount = $data['amount'] ?? 0;
+                            $totalAmountDue = $records->sum('amount_due');
 
                             if ($totalPaymentAmount > $totalAmountDue) {
                                 $formattedTotalAmountDue = CurrencyConverter::formatCentsToMoney($totalAmountDue);
                             }
                         })
                         ->action(function (Collection $records, Tables\Actions\BulkAction $action, array $data) {
-                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
+                            $totalPaymentAmount = $data['amount'] ?? 0;
                             $remainingAmount = $totalPaymentAmount;
 
                             $records->each(function (Bill $record) use (&$remainingAmount, $data) {
-                                $amountDue = $record->getRawOriginal('amount_due');
+                                $amountDue = $record->amount_due;
 
                                 if ($amountDue <= 0 || $remainingAmount <= 0) {
                                     return;
                                 }
 
                                 $paymentAmount = min($amountDue, $remainingAmount);
-                                $data['amount'] = CurrencyConverter::convertCentsToFormatSimple($paymentAmount);
+                                $data['amount'] = $paymentAmount;
 
                                 $record->recordPayment($data);
                                 $remainingAmount -= $paymentAmount;

app/Filament/Company/Resources/Purchases/BillResource/Pages/EditBill.php

 
         $record = parent::handleRecordUpdate($record, $data);
 
-        if (! $record->initialTransaction) {
-            $record->createInitialTransaction();
-        } else {
-            $record->updateInitialTransaction();
-        }
+        $record->updateInitialTransaction();
 
         return $record;
     }

app/Filament/Company/Resources/Purchases/BillResource/RelationManagers/PaymentsRelationManager.php

 
                                 $billCurrency = $ownerRecord->currency_code;
 
-                                if (! CurrencyConverter::isValidAmount($state, $billCurrency)) {
+                                if (! CurrencyConverter::isValidAmount($state, 'USD')) {
                                     return null;
                                 }
 
-                                $amountDue = $ownerRecord->getRawOriginal('amount_due');
+                                $amountDue = $ownerRecord->amount_due;
 
-                                $amount = CurrencyConverter::convertToCents($state, $billCurrency);
+                                $amount = CurrencyConverter::convertToCents($state, 'USD');
 
                                 if ($amount <= 0) {
                                     return 'Please enter a valid positive amount';
                                 }
 
-                                $currentPaymentAmount = $record?->getRawOriginal('amount') ?? 0;
+                                $currentPaymentAmount = $record?->amount ?? 0;
 
                                 $newAmountDue = $amountDue - $amount + $currentPaymentAmount;
 
                                 };
                             })
                             ->rules([
-                                static fn (RelationManager $livewire): Closure => static function (string $attribute, $value, Closure $fail) use ($livewire) {
-                                    /** @var Bill $bill */
-                                    $bill = $livewire->getOwnerRecord();
-
-                                    if (! CurrencyConverter::isValidAmount($value, $bill->currency_code)) {
+                                static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
+                                    if (! CurrencyConverter::isValidAmount($value, 'USD')) {
                                         $fail('Please enter a valid amount');
                                     }
                                 },
                         $bill = $livewire->getOwnerRecord();
                         $billCurrency = $bill->currency_code;
 
-                        if (empty($amount) || empty($bankAccountId) || ! CurrencyConverter::isValidAmount($amount, $billCurrency)) {
+                        if (empty($amount) || empty($bankAccountId) || ! CurrencyConverter::isValidAmount($amount, 'USD')) {
                             return null;
                         }
 
                         }
 
                         // Convert amount from bill currency to bank currency
-                        $amountInBillCurrencyCents = CurrencyConverter::convertToCents($amount, $billCurrency);
+                        $amountInBillCurrencyCents = CurrencyConverter::convertToCents($amount, 'USD');
                         $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
                             $amountInBillCurrencyCents,
                             $billCurrency,
                         }
                     )
                     ->sortable()
-                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code ?? CurrencyAccessor::getDefaultCurrency(), true),
+                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code ?? CurrencyAccessor::getDefaultCurrency()),
             ])
             ->filters([
                 //

app/Filament/Company/Resources/Sales/EstimateResource.php

                                                 return;
                                             }
 
-                                            $unitPrice = CurrencyConverter::convertToFloat($offeringRecord->price, $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency());
+                                            $unitPrice = CurrencyConverter::convertCentsToFormatSimple($offeringRecord->price, 'USD');
 
                                             $set('description', $offeringRecord->description);
                                             $set('unit_price', $unitPrice);
                                     ->default(1),
                                 Forms\Components\TextInput::make('unit_price')
                                     ->hiddenLabel()
-                                    ->numeric()
+                                    ->money(useAffix: false)
                                     ->live()
-                                    ->maxValue(9999999999.99)
                                     ->default(0),
                                 Forms\Components\Group::make([
                                     CreateAdjustmentSelect::make('salesTaxes')
                                     ->extraAttributes(['class' => 'text-left sm:text-right'])
                                     ->content(function (Forms\Get $get) {
                                         $quantity = max((float) ($get('quantity') ?? 0), 0);
-                                        $unitPrice = max((float) ($get('unit_price') ?? 0), 0);
+                                        $unitPrice = CurrencyConverter::isValidAmount($get('unit_price'), 'USD')
+                                            ? CurrencyConverter::convertToFloat($get('unit_price'), 'USD')
+                                            : 0;
                                         $salesTaxes = $get('salesTaxes') ?? [];
                                         $salesDiscounts = $get('salesDiscounts') ?? [];
                                         $currencyCode = $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency();

app/Filament/Company/Resources/Sales/InvoiceResource.php

                                         $invoiceDate = $get('date');
                                         $paymentTerms = $get('payment_terms');
 
-                                        if (! $invoiceDate || $paymentTerms === 'custom') {
+                                        if (! $invoiceDate || $paymentTerms === 'custom' || ! $paymentTerms) {
                                             return;
                                         }
 
                                                 return;
                                             }
 
-                                            $unitPrice = CurrencyConverter::convertToFloat($offeringRecord->price, $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency());
+                                            $unitPrice = CurrencyConverter::convertCentsToFormatSimple($offeringRecord->price, 'USD');
 
                                             $set('description', $offeringRecord->description);
                                             $set('unit_price', $unitPrice);
                                     ->default(1),
                                 Forms\Components\TextInput::make('unit_price')
                                     ->hiddenLabel()
-                                    ->numeric()
+                                    ->money(useAffix: false)
                                     ->live()
-                                    ->maxValue(9999999999.99)
                                     ->default(0),
                                 Forms\Components\Group::make([
                                     CreateAdjustmentSelect::make('salesTaxes')
                                     ->extraAttributes(['class' => 'text-left sm:text-right'])
                                     ->content(function (Forms\Get $get) {
                                         $quantity = max((float) ($get('quantity') ?? 0), 0);
-                                        $unitPrice = max((float) ($get('unit_price') ?? 0), 0);
+                                        $unitPrice = CurrencyConverter::isValidAmount($get('unit_price'), 'USD')
+                                            ? CurrencyConverter::convertToFloat($get('unit_price'), 'USD')
+                                            : 0;
                                         $salesTaxes = $get('salesTaxes') ?? [];
                                         $salesDiscounts = $get('salesDiscounts') ?? [];
                                         $currencyCode = $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency();
                                     ->live(onBlur: true)
                                     ->helperText(function (Invoice $record, $state) {
                                         $invoiceCurrency = $record->currency_code;
-                                        if (! CurrencyConverter::isValidAmount($state, $invoiceCurrency)) {
+                                        if (! CurrencyConverter::isValidAmount($state, 'USD')) {
                                             return null;
                                         }
 
-                                        $amountDue = $record->getRawOriginal('amount_due');
+                                        $amountDue = $record->amount_due;
 
-                                        $amount = CurrencyConverter::convertToCents($state, $invoiceCurrency);
+                                        $amount = CurrencyConverter::convertToCents($state, 'USD');
 
                                         if ($amount <= 0) {
                                             return 'Please enter a valid positive amount';
                                         };
                                     })
                                     ->rules([
-                                        static fn (Invoice $record): Closure => static function (string $attribute, $value, Closure $fail) use ($record) {
-                                            if (! CurrencyConverter::isValidAmount($value, $record->currency_code)) {
+                                        static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
+                                            if (! CurrencyConverter::isValidAmount($value, 'USD')) {
                                                 $fail('Please enter a valid amount');
                                             }
                                         },
                             }
                         })
                         ->mountUsing(function (DocumentCollection $records, Form $form) {
-                            $totalAmountDue = $records->sumMoneyFormattedSimple('amount_due');
+                            $totalAmountDue = $records->sum('amount_due');
 
                             $form->fill([
                                 'posted_at' => now(),
                                 ->label('Notes'),
                         ])
                         ->before(function (DocumentCollection $records, Tables\Actions\BulkAction $action, array $data) {
-                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
-                            $totalAmountDue = $records->sumMoneyInCents('amount_due');
+                            $totalPaymentAmount = $data['amount'] ?? 0;
+                            $totalAmountDue = $records->sum('amount_due');
 
                             if ($totalPaymentAmount > $totalAmountDue) {
                                 $formattedTotalAmountDue = CurrencyConverter::formatCentsToMoney($totalAmountDue);
                             }
                         })
                         ->action(function (DocumentCollection $records, Tables\Actions\BulkAction $action, array $data) {
-                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
+                            $totalPaymentAmount = $data['amount'] ?? 0;
 
                             $remainingAmount = $totalPaymentAmount;
 
                             $records->each(function (Invoice $record) use (&$remainingAmount, $data) {
-                                $amountDue = $record->getRawOriginal('amount_due');
+                                $amountDue = $record->amount_due;
 
                                 if ($amountDue <= 0 || $remainingAmount <= 0) {
                                     return;
 
                                 $paymentAmount = min($amountDue, $remainingAmount);
 
-                                $data['amount'] = CurrencyConverter::convertCentsToFormatSimple($paymentAmount);
+                                $data['amount'] = $paymentAmount;
 
                                 $record->recordPayment($data);
 

app/Filament/Company/Resources/Sales/InvoiceResource/RelationManagers/PaymentsRelationManager.php

 
                                 $invoiceCurrency = $ownerRecord->currency_code;
 
-                                if (! CurrencyConverter::isValidAmount($state, $invoiceCurrency)) {
+                                if (! CurrencyConverter::isValidAmount($state, 'USD')) {
                                     return null;
                                 }
 
-                                $amountDue = $ownerRecord->getRawOriginal('amount_due');
+                                $amountDue = $ownerRecord->amount_due;
 
-                                $amount = CurrencyConverter::convertToCents($state, $invoiceCurrency);
+                                $amount = CurrencyConverter::convertToCents($state, 'USD');
 
                                 if ($amount <= 0) {
                                     return 'Please enter a valid positive amount';
                                 }
 
-                                $currentPaymentAmount = $record?->getRawOriginal('amount') ?? 0;
+                                $currentPaymentAmount = $record?->amount ?? 0;
 
                                 if ($ownerRecord->status === InvoiceStatus::Overpaid) {
                                     $newAmountDue = $amountDue + $amount - $currentPaymentAmount;
                         $invoice = $livewire->getOwnerRecord();
                         $invoiceCurrency = $invoice->currency_code;
 
-                        if (empty($amount) || empty($bankAccountId) || ! CurrencyConverter::isValidAmount($amount, $invoiceCurrency)) {
+                        if (empty($amount) || empty($bankAccountId) || ! CurrencyConverter::isValidAmount($amount, 'USD')) {
                             return null;
                         }
 
                         }
 
                         // Convert amount from invoice currency to bank currency
-                        $amountInInvoiceCurrencyCents = CurrencyConverter::convertToCents($amount, $invoiceCurrency);
+                        $amountInInvoiceCurrencyCents = CurrencyConverter::convertToCents($amount, 'USD');
                         $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
                             $amountInInvoiceCurrencyCents,
                             $invoiceCurrency,
                         }
                     )
                     ->sortable()
-                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code ?? CurrencyAccessor::getDefaultCurrency(), true),
+                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code ?? CurrencyAccessor::getDefaultCurrency()),
             ])
             ->filters([
                 //

app/Filament/Company/Resources/Sales/RecurringInvoiceResource.php

                                                 return;
                                             }
 
-                                            $unitPrice = CurrencyConverter::convertToFloat($offeringRecord->price, $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency());
+                                            $unitPrice = CurrencyConverter::convertCentsToFormatSimple($offeringRecord->price, 'USD');
 
                                             $set('description', $offeringRecord->description);
                                             $set('unit_price', $unitPrice);
                                     ->default(1),
                                 Forms\Components\TextInput::make('unit_price')
                                     ->hiddenLabel()
-                                    ->numeric()
+                                    ->money(useAffix: false)
                                     ->live()
-                                    ->maxValue(9999999999.99)
                                     ->default(0),
                                 Forms\Components\Group::make([
                                     CreateAdjustmentSelect::make('salesTaxes')
                                     ->extraAttributes(['class' => 'text-left sm:text-right'])
                                     ->content(function (Forms\Get $get) {
                                         $quantity = max((float) ($get('quantity') ?? 0), 0);
-                                        $unitPrice = max((float) ($get('unit_price') ?? 0), 0);
+                                        $unitPrice = CurrencyConverter::isValidAmount($get('unit_price'), 'USD')
+                                            ? CurrencyConverter::convertToFloat($get('unit_price'), 'USD')
+                                            : 0;
                                         $salesTaxes = $get('salesTaxes') ?? [];
                                         $salesDiscounts = $get('salesDiscounts') ?? [];
                                         $currencyCode = $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency();

app/Models/Accounting/Bill.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\MoneyCast;
 use App\Casts\RateCast;
 use App\Collections\Accounting\DocumentCollection;
 use App\Enums\Accounting\AdjustmentComputation;
 use Illuminate\Database\Eloquent\Attributes\CollectedBy;
 use Illuminate\Database\Eloquent\Attributes\ObservedBy;
 use Illuminate\Database\Eloquent\Builder;
-use Illuminate\Database\Eloquent\Casts\Attribute;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\MorphMany;
         'discount_method' => DocumentDiscountMethod::class,
         'discount_computation' => AdjustmentComputation::class,
         'discount_rate' => RateCast::class,
-        'subtotal' => MoneyCast::class,
-        'tax_total' => MoneyCast::class,
-        'discount_total' => MoneyCast::class,
-        'total' => MoneyCast::class,
-        'amount_paid' => MoneyCast::class,
-        'amount_due' => MoneyCast::class,
     ];
 
     public function vendor(): BelongsTo
         return $this->amount_due;
     }
 
-    protected function isCurrentlyOverdue(): Attribute
+    public function shouldBeOverdue(): bool
     {
-        return Attribute::get(function () {
-            return $this->due_date->isBefore(today()) && $this->canBeOverdue();
-        });
+        return $this->due_date->isBefore(today()) && $this->canBeOverdue();
     }
 
     public function wasInitialized(): bool
         $requiresConversion = $billCurrency !== $bankAccountCurrency;
 
         // Store the original payment amount in bill currency before any conversion
-        $amountInBillCurrencyCents = CurrencyConverter::convertToCents($data['amount'], $billCurrency);
+        $amountInBillCurrencyCents = $data['amount'];
 
         if ($requiresConversion) {
             $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
                 $billCurrency,
                 $bankAccountCurrency
             );
-            $formattedAmountForBankCurrency = CurrencyConverter::convertCentsToFormatSimple(
-                $amountInBankCurrencyCents,
-                $bankAccountCurrency
-            );
+            $formattedAmountForBankCurrency = $amountInBankCurrencyCents;
         } else {
-            $formattedAmountForBankCurrency = $data['amount']; // Already in simple format
+            $formattedAmountForBankCurrency = $amountInBillCurrencyCents;
         }
 
         // Create transaction with converted amount
     public function createInitialTransaction(?Carbon $postedAt = null): void
     {
         $postedAt ??= $this->date;
-
-        $total = $this->formatAmountToDefaultCurrency($this->getRawOriginal('total'));
-
-        $transaction = $this->transactions()->create([
-            'company_id' => $this->company_id,
-            'type' => TransactionType::Journal,
-            'posted_at' => $postedAt,
-            'amount' => $total,
-            'description' => 'Bill Creation for Bill #' . $this->bill_number,
-        ]);
-
         $baseDescription = "{$this->vendor->name}: Bill #{$this->bill_number}";
 
-        $transaction->journalEntries()->create([
-            'company_id' => $this->company_id,
+        $journalEntryData = [];
+
+        $totalInBillCurrency = $this->total;
+        $journalEntryData[] = [
             'type' => JournalEntryType::Credit,
             'account_id' => Account::getAccountsPayableAccount($this->company_id)->id,
-            'amount' => $total,
+            'amount_in_bill_currency' => $totalInBillCurrency,
             'description' => $baseDescription,
-        ]);
+        ];
 
-        $totalLineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $this->lineItems()->sum('subtotal'));
-        $billDiscountTotalCents = $this->convertAmountToDefaultCurrency((int) $this->getRawOriginal('discount_total'));
-        $remainingDiscountCents = $billDiscountTotalCents;
+        $totalLineItemSubtotalInBillCurrency = (int) $this->lineItems()->sum('subtotal');
+        $billDiscountTotalInBillCurrency = (int) $this->discount_total;
+        $remainingDiscountInBillCurrency = $billDiscountTotalInBillCurrency;
 
         foreach ($this->lineItems as $index => $lineItem) {
             $lineItemDescription = "{$baseDescription} › {$lineItem->offering->name}";
+            $lineItemSubtotalInBillCurrency = $lineItem->getRawOriginal('subtotal');
 
-            $lineItemSubtotal = $this->formatAmountToDefaultCurrency($lineItem->getRawOriginal('subtotal'));
-
-            $transaction->journalEntries()->create([
-                'company_id' => $this->company_id,
+            $journalEntryData[] = [
                 'type' => JournalEntryType::Debit,
                 'account_id' => $lineItem->offering->expense_account_id,
-                'amount' => $lineItemSubtotal,
+                'amount_in_bill_currency' => $lineItemSubtotalInBillCurrency,
                 'description' => $lineItemDescription,
-            ]);
+            ];
 
             foreach ($lineItem->adjustments as $adjustment) {
-                $adjustmentAmount = $this->formatAmountToDefaultCurrency($lineItem->calculateAdjustmentTotalAmount($adjustment));
+                $adjustmentAmountInBillCurrency = $lineItem->calculateAdjustmentTotalAmount($adjustment);
 
                 if ($adjustment->isNonRecoverablePurchaseTax()) {
-                    $transaction->journalEntries()->create([
-                        'company_id' => $this->company_id,
+                    $journalEntryData[] = [
                         'type' => JournalEntryType::Debit,
                         'account_id' => $lineItem->offering->expense_account_id,
-                        'amount' => $adjustmentAmount,
+                        'amount_in_bill_currency' => $adjustmentAmountInBillCurrency,
                         'description' => "{$lineItemDescription} ({$adjustment->name})",
-                    ]);
+                    ];
                 } elseif ($adjustment->account_id) {
-                    $transaction->journalEntries()->create([
-                        'company_id' => $this->company_id,
+                    $journalEntryData[] = [
                         'type' => $adjustment->category->isDiscount() ? JournalEntryType::Credit : JournalEntryType::Debit,
                         'account_id' => $adjustment->account_id,
-                        'amount' => $adjustmentAmount,
+                        'amount_in_bill_currency' => $adjustmentAmountInBillCurrency,
                         'description' => $lineItemDescription,
-                    ]);
+                    ];
                 }
             }
 
-            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotalCents > 0) {
-                $lineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $lineItem->getRawOriginal('subtotal'));
+            // Handle per-document discount allocation
+            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotalInBillCurrency > 0) {
+                $lineItemSubtotalInBillCurrency = (int) $lineItem->getRawOriginal('subtotal');
 
                 if ($index === $this->lineItems->count() - 1) {
-                    $lineItemDiscount = $remainingDiscountCents;
+                    $lineItemDiscountInBillCurrency = $remainingDiscountInBillCurrency;
                 } else {
-                    $lineItemDiscount = (int) round(
-                        ($lineItemSubtotalCents / $totalLineItemSubtotalCents) * $billDiscountTotalCents
+                    $lineItemDiscountInBillCurrency = (int) round(
+                        ($lineItemSubtotalInBillCurrency / $totalLineItemSubtotalInBillCurrency) * $billDiscountTotalInBillCurrency
                     );
-                    $remainingDiscountCents -= $lineItemDiscount;
+                    $remainingDiscountInBillCurrency -= $lineItemDiscountInBillCurrency;
                 }
 
-                if ($lineItemDiscount > 0) {
-                    $transaction->journalEntries()->create([
-                        'company_id' => $this->company_id,
+                if ($lineItemDiscountInBillCurrency > 0) {
+                    $journalEntryData[] = [
                         'type' => JournalEntryType::Credit,
                         'account_id' => Account::getPurchaseDiscountAccount($this->company_id)->id,
-                        'amount' => CurrencyConverter::convertCentsToFormatSimple($lineItemDiscount),
+                        'amount_in_bill_currency' => $lineItemDiscountInBillCurrency,
                         'description' => "{$lineItemDescription} (Proportional Discount)",
-                    ]);
+                    ];
                 }
             }
         }
+
+        // Convert amounts to default currency
+        $totalDebitsInDefaultCurrency = 0;
+        $totalCreditsInDefaultCurrency = 0;
+
+        foreach ($journalEntryData as &$entry) {
+            $entry['amount_in_default_currency'] = $this->formatAmountToDefaultCurrency($entry['amount_in_bill_currency']);
+
+            if ($entry['type'] === JournalEntryType::Debit) {
+                $totalDebitsInDefaultCurrency += $entry['amount_in_default_currency'];
+            } else {
+                $totalCreditsInDefaultCurrency += $entry['amount_in_default_currency'];
+            }
+        }
+
+        unset($entry);
+
+        // Handle currency conversion imbalance
+        $imbalance = $totalDebitsInDefaultCurrency - $totalCreditsInDefaultCurrency;
+        if ($imbalance !== 0) {
+            $targetType = $imbalance > 0 ? JournalEntryType::Credit : JournalEntryType::Debit;
+            $adjustmentAmount = abs($imbalance);
+
+            // Find last entry of target type and adjust it
+            $lastKey = array_key_last(array_filter($journalEntryData, fn ($entry) => $entry['type'] === $targetType, ARRAY_FILTER_USE_BOTH));
+            $journalEntryData[$lastKey]['amount_in_default_currency'] += $adjustmentAmount;
+
+            if ($targetType === JournalEntryType::Debit) {
+                $totalDebitsInDefaultCurrency += $adjustmentAmount;
+            } else {
+                $totalCreditsInDefaultCurrency += $adjustmentAmount;
+            }
+        }
+
+        if ($totalDebitsInDefaultCurrency !== $totalCreditsInDefaultCurrency) {
+            throw new \Exception('Journal entries do not balance for Bill #' . $this->bill_number . '. Debits: ' . $totalDebitsInDefaultCurrency . ', Credits: ' . $totalCreditsInDefaultCurrency);
+        }
+
+        // Create the transaction using the sum of debits
+        $transaction = $this->transactions()->create([
+            'company_id' => $this->company_id,
+            'type' => TransactionType::Journal,
+            'posted_at' => $postedAt,
+            'amount' => $totalDebitsInDefaultCurrency,
+            'description' => 'Bill Creation for Bill #' . $this->bill_number,
+        ]);
+
+        // Create all journal entries
+        foreach ($journalEntryData as $entry) {
+            $transaction->journalEntries()->create([
+                'company_id' => $this->company_id,
+                'type' => $entry['type'],
+                'account_id' => $entry['account_id'],
+                'amount' => $entry['amount_in_default_currency'],
+                'description' => $entry['description'],
+            ]);
+        }
     }
 
     public function updateInitialTransaction(): void
     {
-        $transaction = $this->initialTransaction;
-
-        if ($transaction) {
-            $transaction->delete();
-        }
+        $this->initialTransaction?->delete();
 
         $this->createInitialTransaction();
     }
         return $amountCents;
     }
 
-    public function formatAmountToDefaultCurrency(int $amountCents): string
+    public function formatAmountToDefaultCurrency(int $amountCents): int
     {
-        $convertedCents = $this->convertAmountToDefaultCurrency($amountCents);
-
-        return CurrencyConverter::convertCentsToFormatSimple($convertedCents);
+        return $this->convertAmountToDefaultCurrency($amountCents);
     }
 
     public static function getReplicateAction(string $action = ReplicateAction::class): MountableAction

app/Models/Accounting/DocumentLineItem.php

 namespace App\Models\Accounting;
 
 use Akaunting\Money\Money;
-use App\Casts\DocumentMoneyCast;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\AdjustmentCategory;
         'updated_by',
     ];
 
-    protected $casts = [
-        'unit_price' => DocumentMoneyCast::class,
-        'subtotal' => DocumentMoneyCast::class,
-        'tax_total' => DocumentMoneyCast::class,
-        'discount_total' => DocumentMoneyCast::class,
-        'total' => DocumentMoneyCast::class,
-    ];
-
     public function documentable(): MorphTo
     {
         return $this->morphTo();

app/Models/Accounting/Estimate.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\MoneyCast;
 use App\Casts\RateCast;
 use App\Collections\Accounting\DocumentCollection;
 use App\Enums\Accounting\AdjustmentComputation;
         'discount_method' => DocumentDiscountMethod::class,
         'discount_computation' => AdjustmentComputation::class,
         'discount_rate' => RateCast::class,
-        'subtotal' => MoneyCast::class,
-        'tax_total' => MoneyCast::class,
-        'discount_total' => MoneyCast::class,
-        'total' => MoneyCast::class,
     ];
 
     protected $appends = [
         return $this->total;
     }
 
-    protected function isCurrentlyExpired(): Attribute
+    public function shouldBeExpired(): bool
     {
-        return Attribute::get(function () {
-            return $this->expiration_date?->isBefore(today());
-        });
+        return $this->expiration_date?->isBefore(today()) && $this->canBeExpired();
     }
 
     public function isDraft(): bool
             'currency_code' => $this->currency_code,
             'discount_method' => $this->discount_method,
             'discount_computation' => $this->discount_computation,
-            'discount_rate' => $this->discount_rate,
+            'discount_rate' => $this->getRawOriginal('discount_rate'),
             'subtotal' => $this->subtotal,
             'tax_total' => $this->tax_total,
             'discount_total' => $this->discount_total,

app/Models/Accounting/Invoice.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\MoneyCast;
 use App\Casts\RateCast;
 use App\Collections\Accounting\DocumentCollection;
 use App\Enums\Accounting\AdjustmentComputation;
         'discount_method' => DocumentDiscountMethod::class,
         'discount_computation' => AdjustmentComputation::class,
         'discount_rate' => RateCast::class,
-        'subtotal' => MoneyCast::class,
-        'tax_total' => MoneyCast::class,
-        'discount_total' => MoneyCast::class,
-        'total' => MoneyCast::class,
-        'amount_paid' => MoneyCast::class,
-        'amount_due' => MoneyCast::class,
     ];
 
     protected $appends = [
             ->where('status', InvoiceStatus::Overdue);
     }
 
-    protected function isCurrentlyOverdue(): Attribute
+    public function shouldBeOverdue(): bool
     {
-        return Attribute::get(function () {
-            return $this->due_date->isBefore(today()) && $this->canBeOverdue();
-        });
+        return $this->due_date->isBefore(today()) && $this->canBeOverdue();
     }
 
     public function isDraft(): bool
         $requiresConversion = $invoiceCurrency !== $bankAccountCurrency;
 
         // Store the original payment amount in invoice currency before any conversion
-        $amountInInvoiceCurrencyCents = CurrencyConverter::convertToCents($data['amount'], $invoiceCurrency);
+        $amountInInvoiceCurrencyCents = $data['amount'];
 
         if ($requiresConversion) {
             $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
                 $invoiceCurrency,
                 $bankAccountCurrency
             );
-            $formattedAmountForBankCurrency = CurrencyConverter::convertCentsToFormatSimple(
-                $amountInBankCurrencyCents,
-                $bankAccountCurrency
-            );
+            $formattedAmountForBankCurrency = $amountInBankCurrencyCents;
         } else {
-            $formattedAmountForBankCurrency = $data['amount']; // Already in simple format
+            $formattedAmountForBankCurrency = $amountInInvoiceCurrencyCents;
         }
 
         // Create transaction
 
     public function createApprovalTransaction(): void
     {
-        $total = $this->formatAmountToDefaultCurrency($this->getRawOriginal('total'));
-
-        $transaction = $this->transactions()->create([
-            'company_id' => $this->company_id,
-            'type' => TransactionType::Journal,
-            'posted_at' => $this->date,
-            'amount' => $total,
-            'description' => 'Invoice Approval for Invoice #' . $this->invoice_number,
-        ]);
-
         $baseDescription = "{$this->client->name}: Invoice #{$this->invoice_number}";
 
-        $transaction->journalEntries()->create([
-            'company_id' => $this->company_id,
+        $journalEntryData = [];
+
+        $totalInInvoiceCurrency = $this->total;
+        $journalEntryData[] = [
             'type' => JournalEntryType::Debit,
             'account_id' => Account::getAccountsReceivableAccount($this->company_id)->id,
-            'amount' => $total,
+            'amount_in_invoice_currency' => $totalInInvoiceCurrency,
             'description' => $baseDescription,
-        ]);
+        ];
 
-        $totalLineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $this->lineItems()->sum('subtotal'));
-        $invoiceDiscountTotalCents = $this->convertAmountToDefaultCurrency((int) $this->getRawOriginal('discount_total'));
-        $remainingDiscountCents = $invoiceDiscountTotalCents;
+        $totalLineItemSubtotalInInvoiceCurrency = (int) $this->lineItems()->sum('subtotal');
+        $invoiceDiscountTotalInInvoiceCurrency = (int) $this->discount_total;
+        $remainingDiscountInInvoiceCurrency = $invoiceDiscountTotalInInvoiceCurrency;
 
         foreach ($this->lineItems as $index => $lineItem) {
             $lineItemDescription = "{$baseDescription} › {$lineItem->offering->name}";
+            $lineItemSubtotalInInvoiceCurrency = $lineItem->subtotal;
 
-            $lineItemSubtotal = $this->formatAmountToDefaultCurrency($lineItem->getRawOriginal('subtotal'));
-
-            $transaction->journalEntries()->create([
-                'company_id' => $this->company_id,
+            $journalEntryData[] = [
                 'type' => JournalEntryType::Credit,
                 'account_id' => $lineItem->offering->income_account_id,
-                'amount' => $lineItemSubtotal,
+                'amount_in_invoice_currency' => $lineItemSubtotalInInvoiceCurrency,
                 'description' => $lineItemDescription,
-            ]);
+            ];
 
             foreach ($lineItem->adjustments as $adjustment) {
-                $adjustmentAmount = $this->formatAmountToDefaultCurrency($lineItem->calculateAdjustmentTotalAmount($adjustment));
+                $adjustmentAmountInInvoiceCurrency = $lineItem->calculateAdjustmentTotalAmount($adjustment);
 
-                $transaction->journalEntries()->create([
-                    'company_id' => $this->company_id,
+                $journalEntryData[] = [
                     'type' => $adjustment->category->isDiscount() ? JournalEntryType::Debit : JournalEntryType::Credit,
                     'account_id' => $adjustment->account_id,
-                    'amount' => $adjustmentAmount,
+                    'amount_in_invoice_currency' => $adjustmentAmountInInvoiceCurrency,
                     'description' => $lineItemDescription,
-                ]);
+                ];
             }
 
-            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotalCents > 0) {
-                $lineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $lineItem->getRawOriginal('subtotal'));
+            // Handle per-document discount allocation
+            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotalInInvoiceCurrency > 0) {
+                $lineItemSubtotalInInvoiceCurrency = $lineItem->subtotal;
 
                 if ($index === $this->lineItems->count() - 1) {
-                    $lineItemDiscount = $remainingDiscountCents;
+                    $lineItemDiscountInInvoiceCurrency = $remainingDiscountInInvoiceCurrency;
                 } else {
-                    $lineItemDiscount = (int) round(
-                        ($lineItemSubtotalCents / $totalLineItemSubtotalCents) * $invoiceDiscountTotalCents
+                    $lineItemDiscountInInvoiceCurrency = (int) round(
+                        ($lineItemSubtotalInInvoiceCurrency / $totalLineItemSubtotalInInvoiceCurrency) * $invoiceDiscountTotalInInvoiceCurrency
                     );
-                    $remainingDiscountCents -= $lineItemDiscount;
+                    $remainingDiscountInInvoiceCurrency -= $lineItemDiscountInInvoiceCurrency;
                 }
 
-                if ($lineItemDiscount > 0) {
-                    $transaction->journalEntries()->create([
-                        'company_id' => $this->company_id,
+                if ($lineItemDiscountInInvoiceCurrency > 0) {
+                    $journalEntryData[] = [
                         'type' => JournalEntryType::Debit,
                         'account_id' => Account::getSalesDiscountAccount($this->company_id)->id,
-                        'amount' => CurrencyConverter::convertCentsToFormatSimple($lineItemDiscount),
+                        'amount_in_invoice_currency' => $lineItemDiscountInInvoiceCurrency,
                         'description' => "{$lineItemDescription} (Proportional Discount)",
-                    ]);
+                    ];
                 }
             }
         }
+
+        // Convert amounts to default currency
+        $totalDebitsInDefaultCurrency = 0;
+        $totalCreditsInDefaultCurrency = 0;
+
+        foreach ($journalEntryData as &$entry) {
+            $entry['amount_in_default_currency'] = $this->formatAmountToDefaultCurrency($entry['amount_in_invoice_currency']);
+
+            if ($entry['type'] === JournalEntryType::Debit) {
+                $totalDebitsInDefaultCurrency += $entry['amount_in_default_currency'];
+            } else {
+                $totalCreditsInDefaultCurrency += $entry['amount_in_default_currency'];
+            }
+        }
+
+        unset($entry);
+
+        // Handle currency conversion imbalance
+        $imbalance = $totalDebitsInDefaultCurrency - $totalCreditsInDefaultCurrency;
+        if ($imbalance !== 0) {
+            $targetType = $imbalance > 0 ? JournalEntryType::Credit : JournalEntryType::Debit;
+            $adjustmentAmount = abs($imbalance);
+
+            // Find last entry of target type and adjust it
+            $lastKey = array_key_last(array_filter($journalEntryData, fn ($entry) => $entry['type'] === $targetType, ARRAY_FILTER_USE_BOTH));
+            $journalEntryData[$lastKey]['amount_in_default_currency'] += $adjustmentAmount;
+
+            if ($targetType === JournalEntryType::Debit) {
+                $totalDebitsInDefaultCurrency += $adjustmentAmount;
+            } else {
+                $totalCreditsInDefaultCurrency += $adjustmentAmount;
+            }
+        }
+
+        if ($totalDebitsInDefaultCurrency !== $totalCreditsInDefaultCurrency) {
+            throw new \Exception('Journal entries do not balance for Invoice #' . $this->invoice_number . '. Debits: ' . $totalDebitsInDefaultCurrency . ', Credits: ' . $totalCreditsInDefaultCurrency);
+        }
+
+        // Create the transaction using the sum of debits
+        $transaction = $this->transactions()->create([
+            'company_id' => $this->company_id,
+            'type' => TransactionType::Journal,
+            'posted_at' => $this->date,
+            'amount' => $totalDebitsInDefaultCurrency,
+            'description' => 'Invoice Approval for Invoice #' . $this->invoice_number,
+        ]);
+
+        // Create all journal entries
+        foreach ($journalEntryData as $entry) {
+            $transaction->journalEntries()->create([
+                'company_id' => $this->company_id,
+                'type' => $entry['type'],
+                'account_id' => $entry['account_id'],
+                'amount' => $entry['amount_in_default_currency'],
+                'description' => $entry['description'],
+            ]);
+        }
     }
 
     public function updateApprovalTransaction(): void
     {
-        $transaction = $this->approvalTransaction;
-
-        if ($transaction) {
-            $transaction->delete();
-        }
+        $this->approvalTransaction?->delete();
 
         $this->createApprovalTransaction();
     }
         return $amountCents;
     }
 
-    public function formatAmountToDefaultCurrency(int $amountCents): string
+    public function formatAmountToDefaultCurrency(int $amountCents): int
     {
-        $convertedCents = $this->convertAmountToDefaultCurrency($amountCents);
-
-        return CurrencyConverter::convertCentsToFormatSimple($convertedCents);
+        return $this->convertAmountToDefaultCurrency($amountCents);
     }
 
     // TODO: Potentially handle this another way

app/Models/Accounting/JournalEntry.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\JournalEntryCast;
 use App\Collections\Accounting\JournalEntryCollection;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 
     protected $casts = [
         'type' => JournalEntryType::class,
-        'amount' => JournalEntryCast::class,
     ];
 
     public function account(): BelongsTo

app/Models/Accounting/RecurringInvoice.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\MoneyCast;
 use App\Casts\RateCast;
 use App\Collections\Accounting\DocumentCollection;
 use App\Enums\Accounting\AdjustmentComputation;
         'discount_method' => DocumentDiscountMethod::class,
         'discount_computation' => AdjustmentComputation::class,
         'discount_rate' => RateCast::class,
-        'subtotal' => MoneyCast::class,
-        'tax_total' => MoneyCast::class,
-        'discount_total' => MoneyCast::class,
-        'total' => MoneyCast::class,
     ];
 
     protected $appends = [
             'currency_code' => $this->currency_code,
             'discount_method' => $this->discount_method,
             'discount_computation' => $this->discount_computation,
-            'discount_rate' => $this->discount_rate,
+            'discount_rate' => $this->getRawOriginal('discount_rate'),
             'subtotal' => $this->subtotal,
             'tax_total' => $this->tax_total,
             'discount_total' => $this->discount_total,

app/Models/Accounting/Transaction.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\TransactionAmountCast;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\AccountCategory;
     protected $casts = [
         'type' => TransactionType::class,
         'payment_method' => PaymentMethod::class,
-        'amount' => TransactionAmountCast::class,
         'pending' => 'boolean',
         'reviewed' => 'boolean',
         'posted_at' => 'date',
     public function updateAmountIfBalanced(): void
     {
         if ($this->journalEntries->areBalanced() && $this->journalEntries->sumDebits()->formatSimple() !== $this->getAttributeValue('amount')) {
-            $this->setAttribute('amount', $this->journalEntries->sumDebits()->formatSimple());
+            $this->setAttribute('amount', $this->journalEntries->sumDebits()->getAmount());
             $this->save();
         }
     }

app/Models/Common/Offering.php

 
 namespace App\Models\Common;
 
-use App\Casts\MoneyCast;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\AdjustmentCategory;
 
     protected $casts = [
         'type' => OfferingType::class,
-        'price' => MoneyCast::class,
         'sellable' => 'boolean',
         'purchasable' => 'boolean',
     ];

app/Observers/BillObserver.php

 
     public function saving(Bill $bill): void
     {
-        if ($bill->is_currently_overdue) {
+        if ($bill->isDirty('due_date') && $bill->status === BillStatus::Overdue && ! $bill->shouldBeOverdue() && ! $bill->hasPayments()) {
+            $bill->status = BillStatus::Open;
+
+            return;
+        }
+
+        if ($bill->shouldBeOverdue()) {
             $bill->status = BillStatus::Overdue;
         }
     }

app/Observers/EstimateObserver.php

             return;
         }
 
-        if ($estimate->isDirty('expiration_date') && $estimate->status === EstimateStatus::Expired && ! $estimate->is_currently_expired) {
+        if ($estimate->isDirty('expiration_date') && $estimate->status === EstimateStatus::Expired && ! $estimate->shouldBeExpired()) {
             $estimate->status = $estimate->hasBeenSent() ? EstimateStatus::Sent : EstimateStatus::Unsent;
 
             return;
         }
 
-        if ($estimate->is_currently_expired && $estimate->canBeExpired()) {
+        if ($estimate->shouldBeExpired()) {
             $estimate->status = EstimateStatus::Expired;
         }
     }

app/Observers/InvoiceObserver.php

 {
     public function saving(Invoice $invoice): void
     {
-        if ($invoice->approved_at && $invoice->is_currently_overdue) {
+        if (! $invoice->wasApproved()) {
+            return;
+        }
+
+        if ($invoice->isDirty('due_date') && $invoice->status === InvoiceStatus::Overdue && ! $invoice->shouldBeOverdue() && ! $invoice->hasPayments()) {
+            $invoice->status = $invoice->hasBeenSent() ? InvoiceStatus::Sent : InvoiceStatus::Unsent;
+
+            return;
+        }
+
+        if ($invoice->shouldBeOverdue()) {
             $invoice->status = InvoiceStatus::Overdue;
         }
     }

app/Observers/TransactionObserver.php

 
                 // Fall back to conversion if metadata is not available
                 $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
-                $amountCents = (int) $transaction->getRawOriginal('amount');
+                $amountCents = (int) $transaction->amount;
 
                 return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $invoiceCurrency);
             });
 
                 // Fall back to conversion if metadata is not available
                 $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
-                $amountCents = (int) $transaction->getRawOriginal('amount');
+                $amountCents = (int) $transaction->amount;
 
                 return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $invoiceCurrency);
             });
 
         $totalPaidInInvoiceCurrencyCents = $depositTotalInInvoiceCurrencyCents - $withdrawalTotalInInvoiceCurrencyCents;
 
-        $invoiceTotalInInvoiceCurrencyCents = (int) $invoice->getRawOriginal('total');
+        $invoiceTotalInInvoiceCurrencyCents = (int) $invoice->total;
 
         $newStatus = match (true) {
             $totalPaidInInvoiceCurrencyCents > $invoiceTotalInInvoiceCurrencyCents => InvoiceStatus::Overpaid,
         }
 
         $invoice->update([
-            'amount_paid' => CurrencyConverter::convertCentsToFormatSimple($totalPaidInInvoiceCurrencyCents, $invoiceCurrency),
+            'amount_paid' => $totalPaidInInvoiceCurrencyCents,
             'status' => $newStatus,
             'paid_at' => $paidAt,
         ]);
 
                 // Fall back to conversion if metadata is not available
                 $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
-                $amountCents = (int) $transaction->getRawOriginal('amount');
+                $amountCents = (int) $transaction->amount;
 
                 return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $billCurrency);
             });
 
         $totalPaidInBillCurrencyCents = $withdrawalTotalInBillCurrencyCents;
 
-        $billTotalInBillCurrencyCents = (int) $bill->getRawOriginal('total');
+        $billTotalInBillCurrencyCents = (int) $bill->total;
 
         $newStatus = match (true) {
             $totalPaidInBillCurrencyCents >= $billTotalInBillCurrencyCents => BillStatus::Paid,
         }
 
         $bill->update([
-            'amount_paid' => CurrencyConverter::convertCentsToFormatSimple($totalPaidInBillCurrencyCents, $billCurrency),
+            'amount_paid' => $totalPaidInBillCurrencyCents,
             'status' => $newStatus,
             'paid_at' => $paidAt,
         ]);

app/Providers/MacroServiceProvider.php

 use Filament\Forms\Components\TextInput;
 use Filament\Infolists\Components\TextEntry;
 use Filament\Support\Enums\IconPosition;
+use Filament\Support\RawJs;
 use Filament\Tables\Columns\TextColumn;
 use Filament\Tables\Contracts\HasTable;
 use Illuminate\Contracts\Support\Htmlable;
                     });
             }
 
-            $this->mask(static function (TextInput $component) use ($currency) {
-                $currency = $component->evaluate($currency);
+            $this->mask(RawJs::make('$money($input)'))
+                ->afterStateHydrated(function (TextInput $component, ?int $state) {
+                    if (blank($state)) {
+                        return;
+                    }
 
-                return moneyMask($currency);
-            });
+                    $formatted = CurrencyConverter::convertCentsToFormatSimple($state, 'USD');
+                    $component->state($formatted);
+                })
+                ->dehydrateStateUsing(function (?string $state): ?int {
+                    if (blank($state)) {
+                        return null;
+                    }
+
+                    // Remove thousand separators
+                    $cleaned = str_replace(',', '', $state);
+
+                    // If no decimal point, assume it's whole dollars (add .00)
+                    if (! str_contains($cleaned, '.')) {
+                        $cleaned .= '.00';
+                    }
+
+                    // Convert to float then to cents (integer)
+                    return (int) round((float) $cleaned * 100);
+                });
 
             return $this;
         });
 
         TextColumn::macro('currency', function (string | Closure | null $currency = null, ?bool $convert = null): static {
             $currency ??= CurrencyAccessor::getDefaultCurrency();
-            $convert ??= true;
+            $convert ??= false;
 
             $this->formatStateUsing(static function (TextColumn $column, $state) use ($currency, $convert): ?string {
                 if (blank($state)) {
 
         TextEntry::macro('currency', function (string | Closure | null $currency = null, ?bool $convert = null): static {
             $currency ??= CurrencyAccessor::getDefaultCurrency();
-            $convert ??= true;
+            $convert ??= false;
 
             $this->formatStateUsing(static function (TextEntry $entry, $state) use ($currency, $convert): ?string {
                 if (blank($state)) {
 
         TextColumn::macro('currencyWithConversion', function (string | Closure | null $currency = null, ?bool $convertFromCents = null): static {
             $currency ??= CurrencyAccessor::getDefaultCurrency();
-            $convertFromCents ??= false;
+            $convertFromCents ??= true;
 
             $this->formatStateUsing(static function (TextColumn $column, $state) use ($currency, $convertFromCents): ?string {
                 if (blank($state)) {

app/Services/ReportService.php

             foreach ($account->journalEntries as $journalEntry) {
                 $transaction = $journalEntry->transaction;
                 $signedAmount = $journalEntry->signed_amount;
-                $amount = $journalEntry->getRawOriginal('amount');
+                $amount = $journalEntry->amount;
 
                 if ($journalEntry->type->isDebit()) {
                     $periodDebitTotal += $amount;

app/Services/TransactionService.php

         });
     }
 
-    private function getConvertedTransactionAmount(Transaction $transaction): string
+    private function getConvertedTransactionAmount(Transaction $transaction): int
     {
         $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
         $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
         return $transaction->amount;
     }
 
-    private function convertToDefaultCurrency(string $amount, string $fromCurrency, string $toCurrency): string
+    private function convertToDefaultCurrency(int $amount, string $fromCurrency, string $toCurrency): int
     {
-        $amountInCents = CurrencyConverter::prepareForAccessor($amount, $fromCurrency);
-
-        $convertedAmountInCents = CurrencyConverter::convertBalance($amountInCents, $fromCurrency, $toCurrency);
-
-        return CurrencyConverter::prepareForMutator($convertedAmountInCents, $toCurrency);
+        return CurrencyConverter::convertBalance($amount, $fromCurrency, $toCurrency);
     }
 
     private function hasRelevantChanges(Transaction $transaction): bool
         return $transaction->wasChanged(['amount', 'account_id', 'bank_account_id', 'type']);
     }
 
-    private function updateJournalEntryForTransaction(JournalEntry $journalEntry, Account $account, string $convertedTransactionAmount): void
+    private function updateJournalEntryForTransaction(JournalEntry $journalEntry, Account $account, int $convertedTransactionAmount): void
     {
         DB::transaction(static function () use ($journalEntry, $account, $convertedTransactionAmount) {
             $journalEntry->update([

app/View/Models/DocumentTotalViewModel.php

     private function calculateLineSubtotalInCents(array $item, string $currencyCode): int
     {
         $quantity = max((float) ($item['quantity'] ?? 0), 0);
-        $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
+        $unitPrice = CurrencyConverter::isValidAmount($item['unit_price'], 'USD')
+            ? CurrencyConverter::convertToFloat($item['unit_price'], 'USD')
+            : 0;
 
         $subtotal = $quantity * $unitPrice;
 
-        return CurrencyConverter::convertToCents($subtotal, $currencyCode);
+        return CurrencyConverter::convertToCents($subtotal, 'USD');
     }
 
     private function calculateAdjustmentsTotalInCents($lineItems, string $key, string $currencyCode): int
     {
-        return $lineItems->reduce(function ($carry, $item) use ($key, $currencyCode) {
+        return $lineItems->reduce(function ($carry, $item) use ($key) {
             $quantity = max((float) ($item['quantity'] ?? 0), 0);
-            $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
+            $unitPrice = CurrencyConverter::isValidAmount($item['unit_price'], 'USD')
+                ? CurrencyConverter::convertToFloat($item['unit_price'], 'USD')
+                : 0;
+
             $adjustmentIds = $item[$key] ?? [];
             $lineTotal = $quantity * $unitPrice;
 
-            $lineTotalInCents = CurrencyConverter::convertToCents($lineTotal, $currencyCode);
+            $lineTotalInCents = CurrencyConverter::convertToCents($lineTotal, 'USD');
 
             $adjustmentTotal = Adjustment::whereIn('id', $adjustmentIds)
                 ->get()
             return RateCalculator::calculatePercentage($subtotalInCents, $scaledDiscountRate);
         }
 
-        if (! CurrencyConverter::isValidAmount($discountRate)) {
+        if (! CurrencyConverter::isValidAmount($discountRate, $currencyCode)) {
             $discountRate = '0';
         }
 
 
     private function calculateAmountDueInCents(int $grandTotalInCents, string $currencyCode): int
     {
-        $amountPaid = $this->data['amount_paid'] ?? '0.00';
-        $amountPaidInCents = CurrencyConverter::convertToCents($amountPaid, $currencyCode);
+        $amountPaidInCents = $this->data['amount_paid'] ?? 0;
 
         return $grandTotalInCents - $amountPaidInCents;
     }

database/factories/Accounting/BillFactory.php

 use App\Models\Common\Vendor;
 use App\Models\Company;
 use App\Models\Setting\DocumentDefault;
-use App\Utilities\Currency\CurrencyConverter;
 use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Support\Carbon;
      */
     public function definition(): array
     {
-        $isFutureBill = $this->faker->boolean();
-
-        if ($isFutureBill) {
-            $billDate = $this->faker->dateTimeBetween('-10 days', '+10 days');
-        } else {
-            $billDate = $this->faker->dateTimeBetween('-1 year', '-30 days');
-        }
-
-        $dueDays = $this->faker->numberBetween(14, 60);
+        $billDate = $this->faker->dateTimeBetween('-1 year', '-1 day');
 
         return [
             'company_id' => 1,
-            'vendor_id' => fn (array $attributes) => Vendor::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
+            'vendor_id' => function (array $attributes) {
+                return Vendor::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id')
+                    ?? Vendor::factory()->state([
+                        'company_id' => $attributes['company_id'],
+                    ]);
+            },
             'bill_number' => $this->faker->unique()->numerify('BILL-####'),
             'order_number' => $this->faker->unique()->numerify('PO-####'),
             'date' => $billDate,
-            'due_date' => Carbon::parse($billDate)->addDays($dueDays),
+            'due_date' => $this->faker->dateTimeInInterval($billDate, '+6 months'),
             'status' => BillStatus::Open,
             'discount_method' => $this->faker->randomElement(DocumentDiscountMethod::class),
             'discount_computation' => AdjustmentComputation::Percentage,
     public function withLineItems(int $count = 3): static
     {
         return $this->afterCreating(function (Bill $bill) use ($count) {
+            // Clear existing line items first
+            $bill->lineItems()->delete();
+
             DocumentLineItem::factory()
                 ->count($count)
                 ->forBill($bill)
     public function initialized(): static
     {
         return $this->afterCreating(function (Bill $bill) {
-            $this->ensureLineItems($bill);
-
-            if ($bill->wasInitialized()) {
-                return;
-            }
-
-            $postedAt = Carbon::parse($bill->date)
-                ->addHours($this->faker->numberBetween(1, 24));
-
-            $bill->createInitialTransaction($postedAt);
+            $this->performInitialization($bill);
         });
     }
 
     public function partial(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Bill $bill) use ($maxPayments) {
-            $this->ensureInitialized($bill);
-
-            $this->withPayments(max: $maxPayments, billStatus: BillStatus::Partial)
-                ->callAfterCreating(collect([$bill]));
+            $this->performInitialization($bill);
+            $this->performPayments($bill, $maxPayments, BillStatus::Partial);
         });
     }
 
     public function paid(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Bill $bill) use ($maxPayments) {
-            $this->ensureInitialized($bill);
-
-            $this->withPayments(max: $maxPayments)
-                ->callAfterCreating(collect([$bill]));
+            $this->performInitialization($bill);
+            $this->performPayments($bill, $maxPayments, BillStatus::Paid);
         });
     }
 
                 'due_date' => now()->subDays($this->faker->numberBetween(1, 30)),
             ])
             ->afterCreating(function (Bill $bill) {
-                $this->ensureInitialized($bill);
+                $this->performInitialization($bill);
             });
     }
 
-    public function withPayments(?int $min = null, ?int $max = null, BillStatus $billStatus = BillStatus::Paid): static
+    protected function performInitialization(Bill $bill): void
     {
-        $min ??= 1;
+        if ($bill->wasInitialized()) {
+            return;
+        }
 
-        return $this->afterCreating(function (Bill $bill) use ($billStatus, $max, $min) {
-            $this->ensureInitialized($bill);
+        $postedAt = Carbon::parse($bill->date)
+            ->addHours($this->faker->numberBetween(1, 24));
 
-            $bill->refresh();
+        if ($postedAt->isAfter(now())) {
+            $postedAt = Carbon::parse($this->faker->dateTimeBetween($bill->date, now()));
+        }
 
-            $amountDue = $bill->getRawOriginal('amount_due');
+        $bill->createInitialTransaction($postedAt);
+    }
 
-            $totalAmountDue = match ($billStatus) {
-                BillStatus::Partial => (int) floor($amountDue * 0.5),
-                default => $amountDue,
-            };
+    protected function performPayments(Bill $bill, int $maxPayments, BillStatus $billStatus): void
+    {
+        $bill->refresh();
 
-            if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
-                return;
-            }
+        $amountDue = $bill->getRawOriginal('amount_due');
 
-            $paymentCount = $max && $min ? $this->faker->numberBetween($min, $max) : $min;
-            $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
-            $remainingAmount = $totalAmountDue;
+        $totalAmountDue = match ($billStatus) {
+            BillStatus::Partial => (int) floor($amountDue * 0.5),
+            default => $amountDue,
+        };
 
-            $paymentDate = Carbon::parse($bill->initialTransaction->posted_at);
-            $paymentDates = [];
+        if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
+            return;
+        }
 
-            for ($i = 0; $i < $paymentCount; $i++) {
-                $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
+        $paymentCount = $this->faker->numberBetween(1, $maxPayments);
+        $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
+        $remainingAmount = $totalAmountDue;
 
-                if ($amount <= 0) {
-                    break;
-                }
+        $initialPaymentDate = Carbon::parse($bill->initialTransaction->posted_at);
+        $maxPaymentDate = now();
+
+        $paymentDates = [];
 
-                $postedAt = $paymentDate->copy()->addDays($this->faker->numberBetween(1, 30));
-                $paymentDates[] = $postedAt;
+        for ($i = 0; $i < $paymentCount; $i++) {
+            $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
 
-                $data = [
-                    'posted_at' => $postedAt,
-                    'amount' => CurrencyConverter::convertCentsToFormatSimple($amount, $bill->currency_code),
-                    'payment_method' => $this->faker->randomElement(PaymentMethod::class),
-                    'bank_account_id' => BankAccount::where('company_id', $bill->company_id)->inRandomOrder()->value('id'),
-                    'notes' => $this->faker->sentence,
-                ];
+            if ($amount <= 0) {
+                break;
+            }
 
-                $bill->recordPayment($data);
-                $remainingAmount -= $amount;
+            if ($i === 0) {
+                $postedAt = $initialPaymentDate->copy()->addDays($this->faker->numberBetween(1, 15));
+            } else {
+                $postedAt = $paymentDates[$i - 1]->copy()->addDays($this->faker->numberBetween(1, 10));
             }
 
-            if ($billStatus !== BillStatus::Paid) {
-                return;
+            if ($postedAt->isAfter($maxPaymentDate)) {
+                $postedAt = Carbon::parse($this->faker->dateTimeBetween($initialPaymentDate, $maxPaymentDate));
             }
 
+            $paymentDates[] = $postedAt;
+
+            $data = [
+                'posted_at' => $postedAt,
+                'amount' => $amount,
+                'payment_method' => $this->faker->randomElement(PaymentMethod::class),
+                'bank_account_id' => BankAccount::where('company_id', $bill->company_id)->inRandomOrder()->value('id'),
+                'notes' => $this->faker->sentence,
+            ];
+
+            $bill->recordPayment($data);
+            $remainingAmount -= $amount;
+        }
+
+        if ($billStatus === BillStatus::Paid && ! empty($paymentDates)) {
             $latestPaymentDate = max($paymentDates);
             $bill->updateQuietly([
                 'status' => $billStatus,
                 'paid_at' => $latestPaymentDate,
             ]);
-        });
+        }
     }
 
     public function configure(): static
     {
         return $this->afterCreating(function (Bill $bill) {
-            $this->ensureInitialized($bill);
+            DocumentLineItem::factory()
+                ->count(3)
+                ->forBill($bill)
+                ->create();
+
+            $this->recalculateTotals($bill);
 
             $number = DocumentDefault::getBaseNumber() + $bill->id;
 
                 'order_number' => "PO-{$number}",
             ]);
 
-            if ($bill->wasInitialized() && $bill->is_currently_overdue) {
+            if ($bill->wasInitialized() && $bill->shouldBeOverdue()) {
                 $bill->updateQuietly([
                     'status' => BillStatus::Overdue,
                 ]);
         });
     }
 
-    protected function ensureLineItems(Bill $bill): void
-    {
-        if (! $bill->hasLineItems()) {
-            $this->withLineItems()->callAfterCreating(collect([$bill]));
-        }
-    }
-
-    protected function ensureInitialized(Bill $bill): void
-    {
-        if (! $bill->wasInitialized()) {
-            $this->initialized()->callAfterCreating(collect([$bill]));
-        }
-    }
-
     protected function recalculateTotals(Bill $bill): void
     {
         $bill->refresh();
                 $scaledRate = RateCalculator::parseLocalizedRate($bill->discount_rate);
                 $discountTotalCents = RateCalculator::calculatePercentage($subtotalCents, $scaledRate);
             } else {
-                $discountTotalCents = CurrencyConverter::convertToCents($bill->discount_rate, $bill->currency_code);
+                $discountTotalCents = $bill->getRawOriginal('discount_rate');
             }
         }
 
         $grandTotalCents = $subtotalCents + $taxTotalCents - $discountTotalCents;
-        $currencyCode = $bill->currency_code;
 
         $bill->update([
-            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents, $currencyCode),
-            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents, $currencyCode),
-            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents, $currencyCode),
-            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents, $currencyCode),
+            'subtotal' => $subtotalCents,
+            'tax_total' => $taxTotalCents,
+            'discount_total' => $discountTotalCents,
+            'total' => $grandTotalCents,
         ]);
     }
 }

database/factories/Accounting/EstimateFactory.php

 use App\Models\Common\Client;
 use App\Models\Company;
 use App\Models\Setting\DocumentDefault;
-use App\Utilities\Currency\CurrencyConverter;
 use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Support\Carbon;
      */
     public function definition(): array
     {
-        $estimateDate = $this->faker->dateTimeBetween('-1 year');
+        $estimateDate = $this->faker->dateTimeBetween('-2 months', '-1 day');
 
         return [
             'company_id' => 1,
-            'client_id' => fn (array $attributes) => Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
+            'client_id' => function (array $attributes) {
+                return Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id')
+                    ?? Client::factory()->state([
+                        'company_id' => $attributes['company_id'],
+                    ]);
+            },
             'header' => 'Estimate',
             'subheader' => 'Estimate',
             'estimate_number' => $this->faker->unique()->numerify('EST-####'),
             'reference_number' => $this->faker->unique()->numerify('REF-####'),
             'date' => $estimateDate,
-            'expiration_date' => Carbon::parse($estimateDate)->addDays($this->faker->numberBetween(14, 30)),
+            'expiration_date' => $this->faker->dateTimeInInterval($estimateDate, '+3 months'),
             'status' => EstimateStatus::Draft,
             'discount_method' => $this->faker->randomElement(DocumentDiscountMethod::class),
             'discount_computation' => AdjustmentComputation::Percentage,
     public function withLineItems(int $count = 3): static
     {
         return $this->afterCreating(function (Estimate $estimate) use ($count) {
+            // Clear existing line items first
+            $estimate->lineItems()->delete();
+
             DocumentLineItem::factory()
                 ->count($count)
                 ->forEstimate($estimate)
     public function approved(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            $this->ensureLineItems($estimate);
-
-            if (! $estimate->canBeApproved()) {
-                return;
-            }
-
-            $approvedAt = Carbon::parse($estimate->date)
-                ->addHours($this->faker->numberBetween(1, 24));
-
-            $estimate->approveDraft($approvedAt);
+            $this->performApproval($estimate);
         });
     }
 
     public function accepted(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            $this->ensureSent($estimate);
+            $this->performSent($estimate);
 
             $acceptedAt = Carbon::parse($estimate->last_sent_at)
                 ->addDays($this->faker->numberBetween(1, 7));
 
+            if ($acceptedAt->isAfter(now())) {
+                $acceptedAt = Carbon::parse($this->faker->dateTimeBetween($estimate->last_sent_at, now()));
+            }
+
             $estimate->markAsAccepted($acceptedAt);
         });
     }
     {
         return $this->afterCreating(function (Estimate $estimate) {
             if (! $estimate->wasAccepted()) {
-                $this->accepted()->callAfterCreating(collect([$estimate]));
+                $this->performSent($estimate);
+
+                $acceptedAt = Carbon::parse($estimate->last_sent_at)
+                    ->addDays($this->faker->numberBetween(1, 7));
+
+                if ($acceptedAt->isAfter(now())) {
+                    $acceptedAt = Carbon::parse($this->faker->dateTimeBetween($estimate->last_sent_at, now()));
+                }
+
+                $estimate->markAsAccepted($acceptedAt);
             }
 
             $convertedAt = Carbon::parse($estimate->accepted_at)
                 ->addDays($this->faker->numberBetween(1, 7));
 
+            if ($convertedAt->isAfter(now())) {
+                $convertedAt = Carbon::parse($this->faker->dateTimeBetween($estimate->accepted_at, now()));
+            }
+
             $estimate->convertToInvoice($convertedAt);
         });
     }
     public function declined(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            $this->ensureSent($estimate);
+            $this->performSent($estimate);
 
             $declinedAt = Carbon::parse($estimate->last_sent_at)
                 ->addDays($this->faker->numberBetween(1, 7));
 
+            if ($declinedAt->isAfter(now())) {
+                $declinedAt = Carbon::parse($this->faker->dateTimeBetween($estimate->last_sent_at, now()));
+            }
+
             $estimate->markAsDeclined($declinedAt);
         });
     }
     public function sent(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            $this->ensureApproved($estimate);
-
-            $sentAt = Carbon::parse($estimate->approved_at)
-                ->addHours($this->faker->numberBetween(1, 24));
-
-            $estimate->markAsSent($sentAt);
+            $this->performSent($estimate);
         });
     }
 
     public function viewed(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            $this->ensureSent($estimate);
+            $this->performSent($estimate);
 
             $viewedAt = Carbon::parse($estimate->last_sent_at)
                 ->addHours($this->faker->numberBetween(1, 24));
 
+            if ($viewedAt->isAfter(now())) {
+                $viewedAt = Carbon::parse($this->faker->dateTimeBetween($estimate->last_sent_at, now()));
+            }
+
             $estimate->markAsViewed($viewedAt);
         });
     }
                 'expiration_date' => now()->subDays($this->faker->numberBetween(1, 30)),
             ])
             ->afterCreating(function (Estimate $estimate) {
-                $this->ensureApproved($estimate);
+                $this->performApproval($estimate);
             });
     }
 
+    protected function performApproval(Estimate $estimate): void
+    {
+        if (! $estimate->canBeApproved()) {
+            throw new \InvalidArgumentException('Estimate cannot be approved. Current status: ' . $estimate->status->value);
+        }
+
+        $approvedAt = Carbon::parse($estimate->date)
+            ->addHours($this->faker->numberBetween(1, 24));
+
+        if ($approvedAt->isAfter(now())) {
+            $approvedAt = Carbon::parse($this->faker->dateTimeBetween($estimate->date, now()));
+        }
+
+        $estimate->approveDraft($approvedAt);
+    }
+
+    protected function performSent(Estimate $estimate): void
+    {
+        if (! $estimate->wasApproved()) {
+            $this->performApproval($estimate);
+        }
+
+        $sentAt = Carbon::parse($estimate->approved_at)
+            ->addHours($this->faker->numberBetween(1, 24));
+
+        if ($sentAt->isAfter(now())) {
+            $sentAt = Carbon::parse($this->faker->dateTimeBetween($estimate->approved_at, now()));
+        }
+
+        $estimate->markAsSent($sentAt);
+    }
+
     public function configure(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            $this->ensureLineItems($estimate);
+            DocumentLineItem::factory()
+                ->count(3)
+                ->forEstimate($estimate)
+                ->create();
+
+            $this->recalculateTotals($estimate);
 
             $number = DocumentDefault::getBaseNumber() + $estimate->id;
 
                 'reference_number' => "REF-{$number}",
             ]);
 
-            if ($estimate->wasApproved() && $estimate->is_currently_expired) {
+            if ($estimate->wasApproved() && $estimate->shouldBeExpired()) {
                 $estimate->updateQuietly([
                     'status' => EstimateStatus::Expired,
                 ]);
         });
     }
 
-    protected function ensureLineItems(Estimate $estimate): void
-    {
-        if (! $estimate->hasLineItems()) {
-            $this->withLineItems()->callAfterCreating(collect([$estimate]));
-        }
-    }
-
-    protected function ensureApproved(Estimate $estimate): void
-    {
-        if (! $estimate->wasApproved()) {
-            $this->approved()->callAfterCreating(collect([$estimate]));
-        }
-    }
-
-    protected function ensureSent(Estimate $estimate): void
-    {
-        if (! $estimate->hasBeenSent()) {
-            $this->sent()->callAfterCreating(collect([$estimate]));
-        }
-    }
-
     protected function recalculateTotals(Estimate $estimate): void
     {
         $estimate->refresh();
                 $scaledRate = RateCalculator::parseLocalizedRate($estimate->discount_rate);
                 $discountTotalCents = RateCalculator::calculatePercentage($subtotalCents, $scaledRate);
             } else {
-                $discountTotalCents = CurrencyConverter::convertToCents($estimate->discount_rate, $estimate->currency_code);
+                $discountTotalCents = $estimate->getRawOriginal('discount_rate');
             }
         }
 
         $grandTotalCents = $subtotalCents + $taxTotalCents - $discountTotalCents;
-        $currencyCode = $estimate->currency_code;
 
         $estimate->update([
-            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents, $currencyCode),
-            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents, $currencyCode),
-            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents, $currencyCode),
-            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents, $currencyCode),
+            'subtotal' => $subtotalCents,
+            'tax_total' => $taxTotalCents,
+            'discount_total' => $discountTotalCents,
+            'total' => $grandTotalCents,
         ]);
     }
 }

database/factories/Accounting/InvoiceFactory.php

 use App\Models\Common\Client;
 use App\Models\Company;
 use App\Models\Setting\DocumentDefault;
-use App\Utilities\Currency\CurrencyConverter;
 use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Support\Carbon;
+use Random\RandomException;
 
 /**
  * @extends Factory<Invoice>
      */
     public function definition(): array
     {
-        $invoiceDate = $this->faker->dateTimeBetween('-1 year');
+        $invoiceDate = $this->faker->dateTimeBetween('-2 months', '-1 day');
 
         return [
             'company_id' => 1,
-            'client_id' => fn (array $attributes) => Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
+            'client_id' => function (array $attributes) {
+                return Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id')
+                    ?? Client::factory()->state([
+                        'company_id' => $attributes['company_id'],
+                    ]);
+            },
             'header' => 'Invoice',
             'subheader' => 'Invoice',
             'invoice_number' => $this->faker->unique()->numerify('INV-####'),
             'order_number' => $this->faker->unique()->numerify('ORD-####'),
             'date' => $invoiceDate,
-            'due_date' => Carbon::parse($invoiceDate)->addDays($this->faker->numberBetween(14, 60)),
+            'due_date' => $this->faker->dateTimeInInterval($invoiceDate, '+3 months'),
             'status' => InvoiceStatus::Draft,
             'discount_method' => $this->faker->randomElement(DocumentDiscountMethod::class),
             'discount_computation' => AdjustmentComputation::Percentage,
     public function withLineItems(int $count = 3): static
     {
         return $this->afterCreating(function (Invoice $invoice) use ($count) {
+            $invoice->lineItems()->delete();
+
             DocumentLineItem::factory()
                 ->count($count)
                 ->forInvoice($invoice)
     public function approved(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            $this->ensureLineItems($invoice);
-
-            if (! $invoice->canBeApproved()) {
-                return;
-            }
-
-            $approvedAt = Carbon::parse($invoice->date)
-                ->addHours($this->faker->numberBetween(1, 24));
-
-            $invoice->approveDraft($approvedAt);
+            $this->performApproval($invoice);
         });
     }
 
     public function sent(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            $this->ensureApproved($invoice);
-
-            $sentAt = Carbon::parse($invoice->approved_at)
-                ->addHours($this->faker->numberBetween(1, 24));
-
-            $invoice->markAsSent($sentAt);
+            $this->performSent($invoice);
         });
     }
 
     public function partial(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Invoice $invoice) use ($maxPayments) {
-            $this->ensureSent($invoice);
-
-            $this->withPayments(max: $maxPayments, invoiceStatus: InvoiceStatus::Partial)
-                ->callAfterCreating(collect([$invoice]));
+            $this->performSent($invoice);
+            $this->performPayments($invoice, $maxPayments, InvoiceStatus::Partial);
         });
     }
 
     public function paid(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Invoice $invoice) use ($maxPayments) {
-            $this->ensureSent($invoice);
-
-            $this->withPayments(max: $maxPayments)
-                ->callAfterCreating(collect([$invoice]));
+            $this->performSent($invoice);
+            $this->performPayments($invoice, $maxPayments, InvoiceStatus::Paid);
         });
     }
 
     public function overpaid(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Invoice $invoice) use ($maxPayments) {
-            $this->ensureSent($invoice);
-
-            $this->withPayments(max: $maxPayments, invoiceStatus: InvoiceStatus::Overpaid)
-                ->callAfterCreating(collect([$invoice]));
+            $this->performSent($invoice);
+            $this->performPayments($invoice, $maxPayments, InvoiceStatus::Overpaid);
         });
     }
 
                 'due_date' => now()->subDays($this->faker->numberBetween(1, 30)),
             ])
             ->afterCreating(function (Invoice $invoice) {
-                $this->ensureApproved($invoice);
+                $this->performApproval($invoice);
             });
     }
 
-    public function withPayments(?int $min = null, ?int $max = null, InvoiceStatus $invoiceStatus = InvoiceStatus::Paid): static
+    protected function performApproval(Invoice $invoice): void
     {
-        $min ??= 1;
+        if (! $invoice->canBeApproved()) {
+            throw new \InvalidArgumentException('Invoice cannot be approved. Current status: ' . $invoice->status->value);
+        }
+
+        $approvedAt = Carbon::parse($invoice->date)
+            ->addHours($this->faker->numberBetween(1, 24));
+
+        if ($approvedAt->isAfter(now())) {
+            $approvedAt = Carbon::parse($this->faker->dateTimeBetween($invoice->date, now()));
+        }
 
-        return $this->afterCreating(function (Invoice $invoice) use ($invoiceStatus, $max, $min) {
-            $this->ensureSent($invoice);
+        $invoice->approveDraft($approvedAt);
+    }
 
-            $invoice->refresh();
+    protected function performSent(Invoice $invoice): void
+    {
+        if (! $invoice->wasApproved()) {
+            $this->performApproval($invoice);
+        }
 
-            $amountDue = $invoice->getRawOriginal('amount_due');
+        $sentAt = Carbon::parse($invoice->approved_at)
+            ->addHours($this->faker->numberBetween(1, 24));
 
-            $totalAmountDue = match ($invoiceStatus) {
-                InvoiceStatus::Overpaid => $amountDue + random_int(1000, 10000),
-                InvoiceStatus::Partial => (int) floor($amountDue * 0.5),
-                default => $amountDue,
-            };
+        if ($sentAt->isAfter(now())) {
+            $sentAt = Carbon::parse($this->faker->dateTimeBetween($invoice->approved_at, now()));
+        }
 
-            if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
-                return;
-            }
+        $invoice->markAsSent($sentAt);
+    }
 
-            $paymentCount = $max && $min ? $this->faker->numberBetween($min, $max) : $min;
-            $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
-            $remainingAmount = $totalAmountDue;
+    /**
+     * @throws RandomException
+     */
+    protected function performPayments(Invoice $invoice, int $maxPayments, InvoiceStatus $invoiceStatus): void
+    {
+        $invoice->refresh();
 
-            $paymentDate = Carbon::parse($invoice->approved_at);
-            $paymentDates = [];
+        $amountDue = $invoice->getRawOriginal('amount_due');
 
-            for ($i = 0; $i < $paymentCount; $i++) {
-                $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
+        $totalAmountDue = match ($invoiceStatus) {
+            InvoiceStatus::Overpaid => $amountDue + random_int(1000, 10000),
+            InvoiceStatus::Partial => (int) floor($amountDue * 0.5),
+            default => $amountDue,
+        };
 
-                if ($amount <= 0) {
-                    break;
-                }
+        if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
+            return;
+        }
+
+        $paymentCount = $this->faker->numberBetween(1, $maxPayments);
+        $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
+        $remainingAmount = $totalAmountDue;
 
-                $postedAt = $paymentDate->copy()->addDays($this->faker->numberBetween(1, 30));
-                $paymentDates[] = $postedAt;
+        $initialPaymentDate = Carbon::parse($invoice->approved_at);
+        $maxPaymentDate = now();
 
-                $data = [
-                    'posted_at' => $postedAt,
-                    'amount' => CurrencyConverter::convertCentsToFormatSimple($amount, $invoice->currency_code),
-                    'payment_method' => $this->faker->randomElement(PaymentMethod::class),
-                    'bank_account_id' => BankAccount::where('company_id', $invoice->company_id)->inRandomOrder()->value('id'),
-                    'notes' => $this->faker->sentence,
-                ];
+        $paymentDates = [];
 
-                $invoice->recordPayment($data);
-                $remainingAmount -= $amount;
+        for ($i = 0; $i < $paymentCount; $i++) {
+            $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
+
+            if ($amount <= 0) {
+                break;
+            }
+
+            if ($i === 0) {
+                $postedAt = $initialPaymentDate->copy()->addDays($this->faker->numberBetween(1, 15));
+            } else {
+                $postedAt = $paymentDates[$i - 1]->copy()->addDays($this->faker->numberBetween(1, 10));
             }
 
-            if ($invoiceStatus !== InvoiceStatus::Paid) {
-                return;
+            if ($postedAt->isAfter($maxPaymentDate)) {
+                $postedAt = Carbon::parse($this->faker->dateTimeBetween($initialPaymentDate, $maxPaymentDate));
             }
 
+            $paymentDates[] = $postedAt;
+
+            $data = [
+                'posted_at' => $postedAt,
+                'amount' => $amount,
+                'payment_method' => $this->faker->randomElement(PaymentMethod::class),
+                'bank_account_id' => BankAccount::where('company_id', $invoice->company_id)->inRandomOrder()->value('id'),
+                'notes' => $this->faker->sentence,
+            ];
+
+            $invoice->recordPayment($data);
+            $remainingAmount -= $amount;
+        }
+
+        if ($invoiceStatus === InvoiceStatus::Paid && ! empty($paymentDates)) {
             $latestPaymentDate = max($paymentDates);
             $invoice->updateQuietly([
                 'status' => $invoiceStatus,
                 'paid_at' => $latestPaymentDate,
             ]);
-        });
+        }
     }
 
     public function configure(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            $this->ensureLineItems($invoice);
+            DocumentLineItem::factory()
+                ->count(3)
+                ->forInvoice($invoice)
+                ->create();
+
+            $this->recalculateTotals($invoice);
 
             $number = DocumentDefault::getBaseNumber() + $invoice->id;
 
                 'order_number' => "ORD-{$number}",
             ]);
 
-            if ($invoice->wasApproved() && $invoice->is_currently_overdue) {
+            if ($invoice->wasApproved() && $invoice->shouldBeOverdue()) {
                 $invoice->updateQuietly([
                     'status' => InvoiceStatus::Overdue,
                 ]);
         });
     }
 
-    protected function ensureLineItems(Invoice $invoice): void
-    {
-        if (! $invoice->hasLineItems()) {
-            $this->withLineItems()->callAfterCreating(collect([$invoice]));
-        }
-    }
-
-    protected function ensureApproved(Invoice $invoice): void
-    {
-        if (! $invoice->wasApproved()) {
-            $this->approved()->callAfterCreating(collect([$invoice]));
-        }
-    }
-
-    protected function ensureSent(Invoice $invoice): void
-    {
-        if (! $invoice->hasBeenSent()) {
-            $this->sent()->callAfterCreating(collect([$invoice]));
-        }
-    }
-
     protected function recalculateTotals(Invoice $invoice): void
     {
         $invoice->refresh();
                 $scaledRate = RateCalculator::parseLocalizedRate($invoice->discount_rate);
                 $discountTotalCents = RateCalculator::calculatePercentage($subtotalCents, $scaledRate);
             } else {
-                $discountTotalCents = CurrencyConverter::convertToCents($invoice->discount_rate, $invoice->currency_code);
+                $discountTotalCents = $invoice->getRawOriginal('discount_rate');
             }
         }
 
         $grandTotalCents = $subtotalCents + $taxTotalCents - $discountTotalCents;
-        $currencyCode = $invoice->currency_code;
 
         $invoice->update([
-            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents, $currencyCode),
-            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents, $currencyCode),
-            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents, $currencyCode),
-            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents, $currencyCode),
+            'subtotal' => $subtotalCents,
+            'tax_total' => $taxTotalCents,
+            'discount_total' => $discountTotalCents,
+            'total' => $grandTotalCents,
         ]);
     }
 }

database/factories/Accounting/RecurringInvoiceFactory.php

 use App\Models\Accounting\RecurringInvoice;
 use App\Models\Common\Client;
 use App\Models\Company;
-use App\Utilities\Currency\CurrencyConverter;
 use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Support\Carbon;
     {
         return [
             'company_id' => 1,
-            'client_id' => fn (array $attributes) => Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
+            'client_id' => function (array $attributes) {
+                return Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id')
+                    ?? Client::factory()->state([
+                        'company_id' => $attributes['company_id'],
+                    ]);
+            },
             'header' => 'Invoice',
             'subheader' => 'Invoice',
             'order_number' => $this->faker->unique()->numerify('ORD-####'),
     public function withLineItems(int $count = 3): static
     {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($count) {
+            // Clear existing line items first
+            $recurringInvoice->lineItems()->delete();
+
             DocumentLineItem::factory()
                 ->count($count)
                 ->forInvoice($recurringInvoice)
         });
     }
 
+    public function configure(): static
+    {
+        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
+            DocumentLineItem::factory()
+                ->count(3)
+                ->forInvoice($recurringInvoice)
+                ->create();
+
+            $this->recalculateTotals($recurringInvoice);
+        });
+    }
+
     public function withSchedule(
         ?Frequency $frequency = null,
         ?Carbon $startDate = null,
         ?EndType $endType = null
     ): static {
-        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($frequency, $endType, $startDate) {
-            $this->ensureLineItems($recurringInvoice);
-
-            $frequency ??= $this->faker->randomElement(Frequency::class);
-            $endType ??= EndType::Never;
-
-            // Adjust the start date range based on frequency
-            $startDate = match ($frequency) {
-                Frequency::Daily => Carbon::parse($this->faker->dateTimeBetween('-30 days')), // At most 30 days back
-                default => $startDate ?? Carbon::parse($this->faker->dateTimeBetween('-1 year')),
-            };
-
-            $state = match ($frequency) {
-                Frequency::Daily => $this->withDailySchedule($startDate, $endType),
-                Frequency::Weekly => $this->withWeeklySchedule($startDate, $endType),
-                Frequency::Monthly => $this->withMonthlySchedule($startDate, $endType),
-                Frequency::Yearly => $this->withYearlySchedule($startDate, $endType),
-                Frequency::Custom => $this->withCustomSchedule($startDate, $endType),
-            };
-
-            $state->callAfterCreating(collect([$recurringInvoice]));
+        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($frequency, $startDate, $endType) {
+            $this->performScheduleSetup($recurringInvoice, $frequency, $startDate, $endType);
         });
     }
 
     public function withDailySchedule(Carbon $startDate, EndType $endType): static
     {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($startDate, $endType) {
-            $this->ensureLineItems($recurringInvoice);
-
             $recurringInvoice->updateQuietly([
                 'frequency' => Frequency::Daily,
                 'start_date' => $startDate,
     public function withWeeklySchedule(Carbon $startDate, EndType $endType): static
     {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($startDate, $endType) {
-            $this->ensureLineItems($recurringInvoice);
-
             $recurringInvoice->updateQuietly([
                 'frequency' => Frequency::Weekly,
                 'day_of_week' => DayOfWeek::from($startDate->dayOfWeek),
     public function withMonthlySchedule(Carbon $startDate, EndType $endType): static
     {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($startDate, $endType) {
-            $this->ensureLineItems($recurringInvoice);
-
             $recurringInvoice->updateQuietly([
                 'frequency' => Frequency::Monthly,
                 'day_of_month' => DayOfMonth::from($startDate->day),
     public function withYearlySchedule(Carbon $startDate, EndType $endType): static
     {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($startDate, $endType) {
-            $this->ensureLineItems($recurringInvoice);
-
             $recurringInvoice->updateQuietly([
                 'frequency' => Frequency::Yearly,
                 'month' => Month::from($startDate->month),
         ?int $intervalValue = null
     ): static {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($intervalType, $intervalValue, $startDate, $endType) {
-            $this->ensureLineItems($recurringInvoice);
-
             $intervalType ??= $this->faker->randomElement(IntervalType::class);
             $intervalValue ??= match ($intervalType) {
                 IntervalType::Day => $this->faker->numberBetween(1, 7),
                     break;
             }
 
-            return $recurringInvoice->updateQuietly($state);
+            $recurringInvoice->updateQuietly($state);
         });
     }
 
     public function approved(): static
     {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
-            $this->ensureLineItems($recurringInvoice);
+            $this->performApproval($recurringInvoice);
+        });
+    }
 
+    public function active(): static
+    {
+        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
             if (! $recurringInvoice->hasSchedule()) {
-                $this->withSchedule()->callAfterCreating(collect([$recurringInvoice]));
+                $this->performScheduleSetup($recurringInvoice);
                 $recurringInvoice->refresh();
             }
 
-            $approvedAt = $recurringInvoice->start_date
-                ? $recurringInvoice->start_date->copy()->subDays($this->faker->numberBetween(1, 7))
-                : now()->subDays($this->faker->numberBetween(1, 30));
-
-            $recurringInvoice->approveDraft($approvedAt);
+            $this->performApproval($recurringInvoice);
         });
     }
 
-    public function active(): static
-    {
-        return $this->withLineItems()
-            ->withSchedule()
-            ->approved();
-    }
-
     public function ended(): static
     {
         return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
-            $this->ensureLineItems($recurringInvoice);
-
             if (! $recurringInvoice->canBeEnded()) {
-                $this->active()->callAfterCreating(collect([$recurringInvoice]));
+                if (! $recurringInvoice->hasSchedule()) {
+                    $this->performScheduleSetup($recurringInvoice);
+                    $recurringInvoice->refresh();
+                }
+
+                $this->performApproval($recurringInvoice);
             }
 
             $endedAt = $recurringInvoice->last_date
         });
     }
 
-    public function configure(): static
+    protected function performScheduleSetup(
+        RecurringInvoice $recurringInvoice,
+        ?Frequency $frequency = null,
+        ?Carbon $startDate = null,
+        ?EndType $endType = null
+    ): void {
+        $frequency ??= $this->faker->randomElement(Frequency::class);
+        $endType ??= EndType::Never;
+
+        // Adjust the start date range based on frequency
+        $startDate = match ($frequency) {
+            Frequency::Daily => Carbon::parse($this->faker->dateTimeBetween('-30 days')), // At most 30 days back
+            default => $startDate ?? Carbon::parse($this->faker->dateTimeBetween('-1 year')),
+        };
+
+        match ($frequency) {
+            Frequency::Daily => $this->performDailySchedule($recurringInvoice, $startDate, $endType),
+            Frequency::Weekly => $this->performWeeklySchedule($recurringInvoice, $startDate, $endType),
+            Frequency::Monthly => $this->performMonthlySchedule($recurringInvoice, $startDate, $endType),
+            Frequency::Yearly => $this->performYearlySchedule($recurringInvoice, $startDate, $endType),
+            Frequency::Custom => $this->performCustomSchedule($recurringInvoice, $startDate, $endType),
+        };
+    }
+
+    protected function performDailySchedule(RecurringInvoice $recurringInvoice, Carbon $startDate, EndType $endType): void
     {
-        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
-            $this->ensureLineItems($recurringInvoice);
-        });
+        $recurringInvoice->updateQuietly([
+            'frequency' => Frequency::Daily,
+            'start_date' => $startDate,
+            'end_type' => $endType,
+        ]);
     }
 
-    protected function ensureLineItems(RecurringInvoice $recurringInvoice): void
+    protected function performWeeklySchedule(RecurringInvoice $recurringInvoice, Carbon $startDate, EndType $endType): void
     {
-        if (! $recurringInvoice->hasLineItems()) {
-            $this->withLineItems()->callAfterCreating(collect([$recurringInvoice]));
+        $recurringInvoice->updateQuietly([
+            'frequency' => Frequency::Weekly,
+            'day_of_week' => DayOfWeek::from($startDate->dayOfWeek),
+            'start_date' => $startDate,
+            'end_type' => $endType,
+        ]);
+    }
+
+    protected function performMonthlySchedule(RecurringInvoice $recurringInvoice, Carbon $startDate, EndType $endType): void
+    {
+        $recurringInvoice->updateQuietly([
+            'frequency' => Frequency::Monthly,
+            'day_of_month' => DayOfMonth::from($startDate->day),
+            'start_date' => $startDate,
+            'end_type' => $endType,
+        ]);
+    }
+
+    protected function performYearlySchedule(RecurringInvoice $recurringInvoice, Carbon $startDate, EndType $endType): void
+    {
+        $recurringInvoice->updateQuietly([
+            'frequency' => Frequency::Yearly,
+            'month' => Month::from($startDate->month),
+            'day_of_month' => DayOfMonth::from($startDate->day),
+            'start_date' => $startDate,
+            'end_type' => $endType,
+        ]);
+    }
+
+    protected function performCustomSchedule(
+        RecurringInvoice $recurringInvoice,
+        Carbon $startDate,
+        EndType $endType,
+        ?IntervalType $intervalType = null,
+        ?int $intervalValue = null
+    ): void {
+        $intervalType ??= $this->faker->randomElement(IntervalType::class);
+        $intervalValue ??= match ($intervalType) {
+            IntervalType::Day => $this->faker->numberBetween(1, 7),
+            IntervalType::Week => $this->faker->numberBetween(1, 4),
+            IntervalType::Month => $this->faker->numberBetween(1, 3),
+            IntervalType::Year => 1,
+        };
+
+        $state = [
+            'frequency' => Frequency::Custom,
+            'interval_type' => $intervalType,
+            'interval_value' => $intervalValue,
+            'start_date' => $startDate,
+            'end_type' => $endType,
+        ];
+
+        // Add interval-specific attributes
+        switch ($intervalType) {
+            case IntervalType::Day:
+                // No additional attributes needed
+                break;
+
+            case IntervalType::Week:
+                $state['day_of_week'] = DayOfWeek::from($startDate->dayOfWeek);
+
+                break;
+
+            case IntervalType::Month:
+                $state['day_of_month'] = DayOfMonth::from($startDate->day);
+
+                break;
+
+            case IntervalType::Year:
+                $state['month'] = Month::from($startDate->month);
+                $state['day_of_month'] = DayOfMonth::from($startDate->day);
+
+                break;
         }
+
+        $recurringInvoice->updateQuietly($state);
+    }
+
+    protected function performApproval(RecurringInvoice $recurringInvoice): void
+    {
+        if (! $recurringInvoice->hasSchedule()) {
+            $this->performScheduleSetup($recurringInvoice);
+            $recurringInvoice->refresh();
+        }
+
+        $approvedAt = $recurringInvoice->start_date
+            ? $recurringInvoice->start_date->copy()->subDays($this->faker->numberBetween(1, 7))
+            : now()->subDays($this->faker->numberBetween(1, 30));
+
+        $recurringInvoice->approveDraft($approvedAt);
     }
 
     protected function recalculateTotals(RecurringInvoice $recurringInvoice): void
                 $scaledRate = RateCalculator::parseLocalizedRate($recurringInvoice->discount_rate);
                 $discountTotalCents = RateCalculator::calculatePercentage($subtotalCents, $scaledRate);
             } else {
-                $discountTotalCents = CurrencyConverter::convertToCents($recurringInvoice->discount_rate, $recurringInvoice->currency_code);
+                $discountTotalCents = $recurringInvoice->getRawOriginal('discount_rate');
             }
         }
 
         $grandTotalCents = $subtotalCents + $taxTotalCents - $discountTotalCents;
-        $currencyCode = $recurringInvoice->currency_code;
 
         $recurringInvoice->update([
-            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents, $currencyCode),
-            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents, $currencyCode),
-            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents, $currencyCode),
-            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents, $currencyCode),
+            'subtotal' => $subtotalCents,
+            'tax_total' => $taxTotalCents,
+            'discount_total' => $discountTotalCents,
+            'total' => $grandTotalCents,
         ]);
     }
 }

database/factories/Common/OfferingFactory.php

             'name' => $this->faker->words(3, true),
             'description' => $this->faker->sentence,
             'type' => $this->faker->randomElement(OfferingType::cases()),
-            'price' => $this->faker->numberBetween(5, 1000),
+            'price' => $this->faker->numberBetween(500, 50000), // $5.00 to $500.00
             'sellable' => false,
             'purchasable' => false,
             'income_account_id' => null,

database/factories/CompanyFactory.php

 
             Invoice::factory()
                 ->count($draftCount)
+                ->withLineItems()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,

tests/Feature/Accounting/InvoiceTest.php

+<?php
+
+use App\Enums\Accounting\InvoiceStatus;
+use App\Models\Accounting\Invoice;
+use App\Utilities\Currency\CurrencyAccessor;
+
+beforeEach(function () {
+    $this->defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+    $this->withOfferings();
+});
+
+it('creates a basic invoice with line items and calculates totals correctly', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBe(3)
+        ->subtotal->toBeGreaterThan(0)
+        ->total->toBeGreaterThan(0)
+        ->amount_due->toBe($invoice->total);
+});
+
+test('approved invoices are marked as Unsent when not Overdue', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->state([
+            'due_date' => now()->addDays(30),
+        ])
+        ->create();
+
+    $invoice->refresh();
+
+    $invoice->approveDraft();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->status->toBe(InvoiceStatus::Unsent)
+        ->wasApproved()->toBeTrue()
+        ->approvalTransaction->not->toBeNull();
+});
+
+test('approved invoices are marked as Overdue when Overdue', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->state([
+            'due_date' => now()->subDays(30),
+        ])
+        ->create();
+
+    $invoice->refresh();
+
+    $invoice->approveDraft();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->status->toBe(InvoiceStatus::Overdue)
+        ->wasApproved()->toBeTrue()
+        ->approvalTransaction->not->toBeNull();
+});

tests/Feature/Accounting/RecurringInvoiceTest.php

     $this->withOfferings();
 });
 
+it('creates a basic recurring invoice with line items and calculates totals correctly', function () {
+    $recurringInvoice = RecurringInvoice::factory()
+        ->withLineItems()
+        ->create();
+
+    $recurringInvoice->refresh();
+
+    expect($recurringInvoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBe(3)
+        ->subtotal->toBeGreaterThan(0)
+        ->total->toBeGreaterThan(0);
+});
+
 test('recurring invoice properly handles months with fewer days for monthly frequency', function () {
     // Start from January 31st
     Carbon::setTestNow('2024-01-31');

tests/Feature/Accounting/TransactionTest.php

 use App\Models\Accounting\Account;
 use App\Models\Accounting\Transaction;
 use App\Utilities\Currency\ConfigureCurrencies;
+use App\Utilities\Currency\CurrencyConverter;
 use Filament\Tables\Actions\DeleteAction;
 use Filament\Tables\Actions\DeleteBulkAction;
 use Filament\Tables\Actions\ReplicateAction;
         ->create();
 
     expect($transaction)
-        ->journalEntries->sumDebits()->getValue()->toEqual($amount)
-        ->journalEntries->sumCredits()->getValue()->toEqual($amount);
+        ->journalEntries->sumDebits()->getAmount()->toEqual($amount)
+        ->journalEntries->sumCredits()->getAmount()->toEqual($amount);
 })->with([
     ['asDeposit', 'forUncategorizedRevenue', 2000],
     ['asWithdrawal', 'forUncategorizedExpense', 500],
     $expectedUSDValue = 1500;
 
     expect($transaction)
-        ->amount->toEqual('1,500.00')
+        ->amount->toBe(1500)
         ->journalEntries->count()->toBe(2)
-        ->journalEntries->sumDebits()->getValue()->toEqual($expectedUSDValue)
-        ->journalEntries->sumCredits()->getValue()->toEqual($expectedUSDValue);
+        ->journalEntries->sumDebits()->getAmount()->toEqual($expectedUSDValue)
+        ->journalEntries->sumCredits()->getAmount()->toEqual($expectedUSDValue);
 });
 
 it('handles multi-currency transfers correctly', function () {
     expect($debitAccount->name)->toBe('Destination Bank Account') // Debit: Destination (USD) account
         ->and($creditAccount->is($foreignBankAccount))->toBeTrue(); // Credit: Foreign Bank Account (CAD) account
 
-    // The 1500 CAD is worth 1102.94 USD (1500 CAD / 1.36)
-    $expectedUSDValue = round(1500 / 1.36, 2);
+    // The 1500 CAD is worth approximately 1103 USD (1500 CAD / 1.36)
+    $expectedUSDValue = CurrencyConverter::convertBalance(1500, 'CAD', 'USD');
 
-    // Verify that the debit is 1102.94 USD and the credit is 1500 CAD converted to 1102.94 USD
-    // Transaction amount stays in source bank account currency (cast is applied)
+    // Verify that the debit and credit are converted to USD cents
+    // Transaction amount stays in source bank account currency
     expect($transaction)
-        ->amount->toEqual('1,500.00')
+        ->amount->toBe(1500)
         ->journalEntries->count()->toBe(2)
-        ->journalEntries->sumDebits()->getValue()->toEqual($expectedUSDValue)
-        ->journalEntries->sumCredits()->getValue()->toEqual($expectedUSDValue);
+        ->journalEntries->sumDebits()->getAmount()->toEqual($expectedUSDValue)
+        ->journalEntries->sumCredits()->getAmount()->toEqual($expectedUSDValue);
 });
 
 it('handles multi-currency deposits correctly', function () {
 
     ConfigureCurrencies::syncCurrencies();
 
-    // Create a deposit of 1500 BHD to the foreign bank account
+    // Create a deposit of 1500 BHD (in fils - BHD subunits) to the foreign bank account
     /** @var Transaction $transaction */
     $transaction = Transaction::factory()
         ->forBankAccount($foreignBankAccount->bankAccount)
     expect($debitAccount->is($foreignBankAccount))->toBeTrue() // Debit: Foreign Bank Account (BHD) account
         ->and($creditAccount->name)->toBe('Uncategorized Income'); // Credit: Uncategorized Income (USD) account
 
-    // Convert to USD using the rate 0.38 BHD per USD
-    $expectedUSDValue = round(1500 / 0.38, 2);
+    $expectedUSDValue = CurrencyConverter::convertBalance(1500, 'BHD', 'USD');
 
-    // Verify that the debit is 39473.68 USD and the credit is 1500 BHD converted to 39473.68 USD
+    // Verify that journal entries are converted to USD cents
     expect($transaction)
-        ->amount->toEqual('1,500.000')
+        ->amount->toBe(1500)
         ->journalEntries->count()->toBe(2)
-        ->journalEntries->sumDebits()->getValue()->toEqual($expectedUSDValue)
-        ->journalEntries->sumCredits()->getValue()->toEqual($expectedUSDValue);
+        ->journalEntries->sumDebits()->getAmount()->toEqual($expectedUSDValue)
+        ->journalEntries->sumCredits()->getAmount()->toEqual($expectedUSDValue);
 });
 
 it('handles multi-currency withdrawals correctly', function () {
     expect($debitAccount->name)->toBe('Uncategorized Expense')
         ->and($creditAccount->is($foreignBankAccount))->toBeTrue();
 
-    $expectedUSDValue = round(1500 / 0.76, 2);
+    $expectedUSDValue = CurrencyConverter::convertBalance(1500, 'GBP', 'USD');
 
     expect($transaction)
-        ->amount->toEqual('1,500.00')
+        ->amount->toBe(1500)
         ->journalEntries->count()->toBe(2)
-        ->journalEntries->sumDebits()->getValue()->toEqual($expectedUSDValue)
-        ->journalEntries->sumCredits()->getValue()->toEqual($expectedUSDValue);
+        ->journalEntries->sumDebits()->getAmount()->toEqual($expectedUSDValue)
+        ->journalEntries->sumCredits()->getAmount()->toEqual($expectedUSDValue);
 });
 
 it('can add an income or expense transaction', function (TransactionType $transactionType, string $actionName) {
 
     expect($transaction)
         ->not->toBeNull()
-        ->amount->toEqual('500.00')
+        ->amount->toBe(50000) // 500.00 in cents
         ->type->toBe($transactionType)
         ->bankAccount->is($defaultBankAccount)->toBeTrue()
         ->account->is($defaultAccount)->toBeTrue()
 
     expect($transaction)
         ->not->toBeNull()
-        ->amount->toEqual('1,500.00')
+        ->amount->toBe(150000) // 1,500.00 in cents
         ->type->toBe(TransactionType::Transfer)
         ->bankAccount->is($sourceBankAccount)->toBeTrue()
         ->account->is($destinationBankAccount)->toBeTrue()
 
     expect($transaction)
         ->not->toBeNull()
-        ->amount->toEqual('1,000.00')
+        ->amount->toBe(100000) // 1,000.00 in cents
         ->type->isJournal()->toBeTrue()
         ->bankAccount->toBeNull()
         ->account->toBeNull()
         ->journalEntries->count()->toBe(2)
-        ->journalEntries->sumDebits()->getValue()->toEqual(1000)
-        ->journalEntries->sumCredits()->getValue()->toEqual(1000)
+        ->journalEntries->sumDebits()->getAmount()->toEqual(100000)
+        ->journalEntries->sumCredits()->getAmount()->toEqual(100000)
         ->and($debitAccount->is($defaultDebitAccount))->toBeTrue()
         ->and($creditAccount->is($defaultCreditAccount))->toBeTrue();
 });
 
     $newDescription = 'Updated Description';
 
+    $formattedAmount = CurrencyConverter::convertCentsToFormatSimple($transaction->amount);
+
     livewire(ListTransactions::class)
         ->mountTableAction(EditTransactionAction::class, $transaction)
         ->assertTableActionDataSet([
             'type' => $transactionType->value,
             'description' => $transaction->description,
-            'amount' => $transaction->amount,
+            'amount' => $formattedAmount,
         ])
         ->setTableActionData([
             'description' => $newDescription,
     $transaction->refresh();
 
     expect($transaction->description)->toBe($newDescription)
-        ->and($transaction->amount)->toEqual('1,500.00');
+        ->and($transaction->amount)->toBe(150000); // 1,500.00 in cents
 })->with([
     TransactionType::Deposit,
     TransactionType::Withdrawal,
 
     $newDescription = 'Updated Transfer Description';
 
+    $formattedAmount = CurrencyConverter::convertCentsToFormatSimple($transaction->amount);
+
     livewire(ListTransactions::class)
         ->mountTableAction(EditTransactionAction::class, $transaction)
         ->assertTableActionDataSet([
             'type' => TransactionType::Transfer->value,
             'description' => $transaction->description,
-            'amount' => $transaction->amount,
+            'amount' => $formattedAmount,
         ])
         ->setTableActionData([
             'description' => $newDescription,
     $transaction->refresh();
 
     expect($transaction->description)->toBe($newDescription)
-        ->and($transaction->amount)->toEqual('2,000.00');
+        ->and($transaction->amount)->toBe(200000); // 2,000.00 in cents
 });
 
 it('replicates a transaction with correct journal entries', function () {
 
     expect($replicatedTransaction)
         ->journalEntries->count()->toBe(2)
-        ->journalEntries->sumDebits()->getValue()->toEqual(1000)
-        ->journalEntries->sumCredits()->getValue()->toEqual(1000)
+        ->journalEntries->sumDebits()->getAmount()->toEqual(1000)
+        ->journalEntries->sumCredits()->getAmount()->toEqual(1000)
         ->description->toBe('(Copy of) ' . $originalTransaction->description)
         ->and($replicatedDebitAccount->name)->toBe($originalDebitAccount->name)
         ->and($replicatedCreditAccount->name)->toBe($originalCreditAccount->name);
 
         expect($replicatedTransaction)
             ->journalEntries->count()->toBe(2)
-            ->journalEntries->sumDebits()->getValue()->toEqual(1000)
-            ->journalEntries->sumCredits()->getValue()->toEqual(1000)
+            ->journalEntries->sumDebits()->getAmount()->toEqual(1000)
+            ->journalEntries->sumCredits()->getAmount()->toEqual(1000)
             ->and($replicatedDebitAccount->name)->toBe($originalDebitAccount->name)
             ->and($replicatedCreditAccount->name)->toBe($originalCreditAccount->name);
     });