Finance - Banking

Bank account management, balance operations, and transaction logging

The Banking component manages player bank accounts, balance operations, and transaction history. It supports personal checking, savings, and organization accounts.

Overview

Access via Banking (server-side only).

Account Types

Personal, Savings, Organization

Balance Operations

Deposit, Withdraw, Charge

Transaction Logs

Full transaction history per account

Joint Accounts

Savings accounts with joint owners

Server-Side Only: All banking operations must be performed on the server. Never attempt to modify balances from the client.

---

Account Management

Banking.Accounts:Get

Get an account by its account number.

Banking.Accounts:Get(accountNumber)

accountNumber · string · required

The bank account number

account · table|nil

Account data or nil if not found

Example:

local account = Banking.Accounts:Get("1234567890")

if account then
    print('Account:', account.Account)
    print('Balance:', account.Balance)
    print('Type:', account.Type)
end

---

Banking.Accounts:CreatePersonal

Creates or retrieves an existing personal checking account for a character. New accounts start with $5,000.

Banking.Accounts:CreatePersonal(ownerSID)

ownerSID · number · required

Character State ID (SID)

account · table

The personal checking account data

Example:

-- During character creation
AddEventHandler('mythic-characters:server:CharacterCreated', function(source, character)
    local account = Banking.Accounts:CreatePersonal(character.SID)

    Logger:Info('Finance', 'Personal account created', {
        console = true,
        file = true
    }, {
        character = character.SID,
        account = account.Account
    })
end)

---

Banking.Accounts:GetPersonal

Retrieves an existing personal checking account.

Banking.Accounts:GetPersonal(ownerSID)

ownerSID · number · required

Character State ID (SID)

account · table|nil

Personal account or nil if none exists

Example:

local player = Fetch:Source(source)
local char = player:GetData('Character')
local stateId = char:GetData('SID')

local account = Banking.Accounts:GetPersonal(stateId)

if account then
    print('Balance: $' .. account.Balance)
end

---

Banking.Accounts:CreatePersonalSavings

Creates a personal savings account with optional joint owners.

Banking.Accounts:CreatePersonalSavings(ownerSID, jointOwners)

ownerSID · number · required

Character State ID

jointOwners · table

Array of State IDs for joint owners

Example:

-- Create savings with a joint owner
local savings = Banking.Accounts:CreatePersonalSavings(char:GetData('SID'), { partnerSID })

---

Banking.Accounts:GetPersonalSavings

Gets all savings accounts a character owns or has joint access to.

Banking.Accounts:GetPersonalSavings(SID)

SID · number · required

Character State ID

accounts · table

Array of savings accounts (owned and joint)

---

Banking.Accounts:AddPersonalSavingsJointOwner

Adds a joint owner to a savings account.

Banking.Accounts:AddPersonalSavingsJointOwner(accountId, jointOwnerSID)

accountId · string · required

Account number

jointOwnerSID · number · required

State ID of the new joint owner

---

Banking.Accounts:RemovePersonalSavingsJointOwner

Removes a joint owner from a savings account.

Banking.Accounts:RemovePersonalSavingsJointOwner(accountId, jointOwnerSID)

---

Banking.Accounts:CreateOrganization

Creates an organization (business/government) bank account.

Banking.Accounts:CreateOrganization(accountId, accountName, startingBalance, jobAccess)

accountId · string · required

Custom account number/ID

accountName · string · required

Display name for the account

startingBalance · number · required

Initial balance

jobAccess · table · required

Array of job access definitions

Example:

-- Create police department account with default permissions
Banking.Accounts:CreateOrganization('police-lspd', 'LSPD Account', 100000, {
    {
        Job = 'police',
        Workplace = 'lspd',
        Permissions = {
            MANAGE = 'BANK_ACCOUNT_MANAGE',
            WITHDRAW = 'BANK_ACCOUNT_WITHDRAW',
            DEPOSIT = 'BANK_ACCOUNT_DEPOSIT',
            TRANSACTIONS = 'BANK_ACCOUNT_TRANSACTIONS',
            BILL = 'BANK_ACCOUNT_BILL',
            BALANCE = 'BANK_ACCOUNT_BALANCE',
        }
    }
})

Permission values are job permission strings (not grade numbers). The system checks if the player’s job has the specified permission via Jobs.Permissions:HasJob. Use strings like 'BANK_ACCOUNT_WITHDRAW' which map to job permission definitions.

---

Banking.Accounts:GetOrganization

Retrieves an organization account.

Banking.Accounts:GetOrganization(accountId)

---

Banking.Accounts:AddOrganizationAccessingJob

Adds job access to an existing organization account.

Banking.Accounts:AddOrganizationAccessingJob(job, workplace, permissionSettings)

---

Banking.Accounts:RemoveOrganizationAccessingJob

Removes job access from an organization account.

Banking.Accounts:RemoveOrganizationAccessingJob(job, workplace)

---

Balance Operations

Banking.Balance:Get

Get the current balance of an account.

Banking.Balance:Get(accountNumber)

accountNumber · string · required

Bank account number

balance · number

Current balance

Example:

local balance = Banking.Balance:Get("1234567890")
print('Current balance: $' .. balance)

---

Banking.Balance:Has

Check if an account has sufficient funds.

Banking.Balance:Has(accountNumber, amount)

accountNumber · string · required

Bank account number

amount · number · required

Amount to check against

hasFunds · boolean

true if balance >= amount

Example:

if Banking.Balance:Has(account.Account, 5000) then
    -- Player can afford it
else
    TriggerClientEvent('mythic-notifications:client:Send', source, {
        message = 'Insufficient funds',
        type = 'error'
    })
end

---

Banking.Balance:Deposit

Deposit funds into an account.

Banking.Balance:Deposit(accountNumber, amount, transactionLog, skipPhoneNoti)

accountNumber · string · required

Bank account number

amount · number · required

Amount to deposit

transactionLog · table · required

Transaction log entry (see Transaction Log Structure below)

skipPhoneNoti · boolean

Skip sending phone notification

newBalance · number

Updated balance after deposit

Example:

local player = Fetch:Source(source)
local char = player:GetData('Character')
local account = Banking.Accounts:GetPersonal(char:GetData('SID'))

local newBalance = Banking.Balance:Deposit(account.Account, 5000, {
    type = 'deposit',
    title = 'Paycheck',
    description = 'Weekly salary payment',
    transactionAccount = false,
    data = {}
})

---

Banking.Balance:Withdraw

Withdraw funds from an account.

Banking.Balance:Withdraw(accountNumber, amount, transactionLog)

accountNumber · string · required

Bank account number

amount · number · required

Amount to withdraw

transactionLog · table · required

Transaction log entry

newBalance · number

Updated balance after withdrawal

Withdraw does NOT check if the account has sufficient funds. Use Charge if you need automatic validation, or check with Has first.

---

Banking.Balance:Charge

Withdraw funds only if the account has sufficient balance.

Banking.Balance:Charge(accountNumber, amount, transactionLog)

accountNumber · string · required

Bank account number

amount · number · required

Amount to charge

transactionLog · table · required

Transaction log entry

result · number|boolean

New balance if successful, false if insufficient funds

Example:

local result = Banking.Balance:Charge(account.Account, 2500, {
    type = 'withdraw',
    title = 'Vehicle Purchase',
    description = 'Bought Elegy RH8',
    transactionAccount = false,
    data = { vehicle = 'elegy' }
})

if result then
    -- Purchase successful, new balance = result
    TriggerClientEvent('mythic-notifications:client:Send', source, {
        message = 'Purchase successful! Balance: $' .. result,
        type = 'success'
    })
else
    TriggerClientEvent('mythic-notifications:client:Send', source, {
        message = 'Insufficient funds',
        type = 'error'
    })
end

---

Transaction Logs

Banking.TransactionLogs:Add

Record a transaction in the account’s history.

Banking.TransactionLogs:Add(accountNumber, type, amount, title, description, transactionAccount, data)

accountNumber · string · required

Bank account number

type · string · required

Transaction type: deposit, withdraw, transfer, paycheck, fine, fine_profit, bill, loan

amount · number · required

Transaction amount

title · string · required

Human-readable title

description · string · required

Transaction details

transactionAccount · string|boolean · required

Related account number, or false if none

data · table

Custom data dictionary

---

Banking.TransactionLogs:Get

Get transaction history for an account.

Banking.TransactionLogs:Get(accountNumber)

accountNumber · string · required

Bank account number

transactions · table

Array of transaction records for the account

---

Transaction Log Structure

{
    type = "deposit",              -- Transaction type
    title = "Paycheck",            -- Display title
    description = "Weekly salary", -- Details
    transactionAccount = false,    -- Related account or false
    data = {}                      -- Custom metadata
}

Transaction Types:

Type	Description
deposit	Funds deposited
withdraw	Funds withdrawn
transfer	Funds transferred between accounts
paycheck	Salary payment
fine	Government fine
fine_profit	Fine revenue share
bill	Bill payment
loan	Loan payment

---

Account Data Structure

{
    Account = "1234567890",    -- Account number
    Name = "Personal Account", -- Display name
    Type = "personal",         -- Account type
    Owner = 123,               -- Owner SID
    Balance = 5000,            -- Current balance
    JointOwners = {},          -- Joint owner SIDs (savings only)
    JobAccess = {}             -- Job access rules (org only)
}

---

Best Practices

Always Use Charge for Purchases

-- ✅ Good: Charge checks balance automatically
local result = Banking.Balance:Charge(account.Account, price, {
    type = 'withdraw',
    title = 'Shop Purchase',
    description = itemName,
    transactionAccount = false,
    data = {}
})

if not result then
    return -- Insufficient funds
end

-- ❌ Bad: Withdraw without checking
Banking.Balance:Withdraw(account.Account, price, transactionLog)

Log All Transactions

-- Always provide meaningful transaction logs
Banking.Balance:Deposit(account.Account, amount, {
    type = 'deposit',
    title = 'Job Payment',
    description = string.format('Payment for %s work', jobLabel),
    transactionAccount = false,
    data = {
        job = jobName,
        hours = hoursWorked
    }
})

Get Account Safely

local player = Fetch:Source(source)
if not player then return end

local char = player:GetData('Character')
if not char then return end

local account = Banking.Accounts:GetPersonal(char:GetData('SID'))
if not account then return end

-- Safe to use account

---

Next Steps

Finance - Payments

Cash, bills, fines, and charges

Finance - Crypto

Cryptocurrency system

Finance - Loans

Loan and credit system

Characters API

Character data access