zai_payment 2.6.1 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21a2f54b50cab4893520a396d33149bd53daf27aa6023fcc2b720fd2c2100e89
-  data.tar.gz: 736516f787ba6acb1d3c40222530606dae8be04e0c2ac222d2f5a367815ad26d
+  metadata.gz: 510e8e99ba15a794801fbfa54f066f9c9df8037b2b4439f1e4f2a11b19509899
+  data.tar.gz: 5f699a364d1cc0f50a6e6e36e4a5ffea274a8c7e761dfa01f0f78d71043f9578
 SHA512:
-  metadata.gz: 0c05de5aa53f36e794f65e0dfb421b997db67c039700b9ea62d96d38abace81d44f6bd7f22e2b98ed2885365c78c3c8ebdb2fde14a737844784379a3f64874d6
-  data.tar.gz: 3731f8af6454bf2ae233e47a8716e06c1290912989a2ba4d9a728341845ebb5d01d0a9e7d903e0fd6f07c38cbbccd9a3931f56d6b1cb84f3e20cb5c0d50f2307
+  metadata.gz: ad9010a7ed0538881749587f2ea3cf2a7e3bf8dde51f1f2856b62a13726f25ef55c5174dce276c024df5d3ea9f7352a049ad2da29e15495dc7e4b838d08c963a
+  data.tar.gz: 2d33996bd2e78ab91f8c2ee27f02d9d5d5f0f139cda22141d4c5e0d0d9358c3906872236f13131448da217665db28ed7d3df360119981b9ba87cc11a2acf9ec6

data/IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,183 @@
+# Batch Transactions Implementation Summary
+
+## Overview
+
+Successfully implemented prelive-only batch transaction endpoints for the Zai Payment Ruby gem. These endpoints allow testing and simulation of batch transaction processing flows in the prelive environment.
+
+## Files Created
+
+### 1. Resource Implementation
+**File:** `lib/zai_payment/resources/batch_transaction.rb`
+
+Implements the `BatchTransaction` resource class with the following methods:
+- `export_transactions` - Exports pending batch transactions to batched state
+- `update_transaction_states` - Updates batch transaction states (12700 or 12000)
+- `process_to_bank_processing` - Convenience method for state 12700
+- `process_to_successful` - Convenience method for state 12000 (triggers webhooks)
+
+**Key Features:**
+- Environment validation (prelive-only)
+- Comprehensive parameter validation
+- Clear error messages
+- Full YARD documentation
+
+### 2. Spec File
+**File:** `spec/zai_payment/resources/batch_transaction_spec.rb`
+
+Comprehensive test coverage including:
+- Export transactions functionality
+- Update transaction states with both state codes
+- Convenience methods (process_to_bank_processing, process_to_successful)
+- Environment validation (prelive vs production)
+- Parameter validation for all methods
+- Multiple transaction ID handling
+- Integration with ZaiPayment module
+
+### 3. Documentation
+
+#### Examples
+**File:** `examples/batch_transactions.md`
+- Complete workflow examples
+- Step-by-step usage guide
+- Error handling examples
+- Multiple transaction processing
+- Webhook testing guide
+
+#### Technical Documentation
+**File:** `docs/batch_transactions.md`
+- Complete method reference with signatures
+- Parameter descriptions and types
+- Return value specifications
+- Error handling details
+- State code documentation
+- Lifecycle diagrams
+- Integration examples
+
+## Files Modified
+
+### 1. Main Module
+**File:** `lib/zai_payment.rb`
+- Added require for batch_transaction resource
+- Added `batch_transactions` accessor method
+
+### 2. Response Class
+**File:** `lib/zai_payment/response.rb`
+- Added "batches" to RESPONSE_DATA_KEYS array
+
+### 3. README
+**File:** `readme.md`
+- Added batch transactions to Features section
+- Added new Quick Start section with example
+- Added to Roadmap as completed feature
+- Added to Examples & Patterns section
+- Added documentation links
+
+## API Endpoints Implemented
+
+### 1. Export Transactions
+**Method:** `GET /batch_transactions/export_transactions`
+**Purpose:** Move all pending batch_transactions to batched state
+**Returns:** Array of transactions with batch_id and transaction id
+
+### 2. Update Transaction States
+**Method:** `PATCH /batches/:id/transaction_states`
+**Purpose:** Move batch transactions between states
+**Supports:**
+- State 12700 (bank_processing)
+- State 12000 (successful - triggers webhooks)
+
+## Usage Example
+
+```ruby
+# Configure for prelive
+ZaiPayment.configure do |config|
+  config.environment = :prelive
+  config.client_id = 'your_client_id'
+  config.client_secret = 'your_client_secret'
+  config.scope = 'your_scope'
+end
+
+# Export transactions
+export_response = ZaiPayment.batch_transactions.export_transactions
+batch_id = export_response.data.first['batch_id']
+transaction_ids = export_response.data.map { |t| t['id'] }
+
+# Move to bank_processing
+ZaiPayment.batch_transactions.process_to_bank_processing(
+  batch_id,
+  exported_ids: transaction_ids
+)
+
+# Complete processing (triggers webhook)
+ZaiPayment.batch_transactions.process_to_successful(
+  batch_id,
+  exported_ids: transaction_ids
+)
+```
+
+## Error Handling
+
+### ConfigurationError
+Raised when attempting to use batch transaction endpoints outside prelive environment.
+
+### ValidationError
+Raised for:
+- Blank or nil batch_id
+- Empty or nil exported_ids array
+- exported_ids not an array
+- exported_ids containing nil or empty values
+- Invalid state codes (not 12700 or 12000)
+
+## Key Design Decisions
+
+1. **Prelive-Only Enforcement**: Environment check in every method to prevent accidental production use
+2. **Convenience Methods**: Separate methods for common operations (process_to_bank_processing, process_to_successful)
+3. **Array Support**: All methods support processing multiple transactions at once
+4. **State Code Constants**: Clear documentation of state codes (12700, 12000)
+5. **Comprehensive Validation**: All parameters validated with clear error messages
+6. **Consistent API**: Follows same patterns as other resources in the gem
+
+## Testing
+
+The implementation includes comprehensive RSpec tests covering:
+- ✅ Happy path for all methods
+- ✅ Error cases (invalid environment, invalid parameters)
+- ✅ Multiple transaction handling
+- ✅ Response structure validation
+- ✅ Integration with main module
+
+## Documentation
+
+Three levels of documentation provided:
+1. **YARD Comments**: Inline documentation in the code
+2. **Examples**: Practical usage examples (`examples/batch_transactions.md`)
+3. **Technical Guide**: Complete reference documentation (`docs/batch_transactions.md`)
+
+## Next Steps
+
+The implementation is complete and ready for use. To use it:
+
+1. Ensure your environment is set to `:prelive`
+2. Access via `ZaiPayment.batch_transactions`
+3. Follow the workflow: export → bank_processing → successful
+4. Handle webhooks triggered by the successful state
+
+## Files Summary
+
+**Created:**
+- `lib/zai_payment/resources/batch_transaction.rb` (172 lines)
+- `spec/zai_payment/resources/batch_transaction_spec.rb` (443 lines)
+- `examples/batch_transactions.md` (276 lines)
+- `docs/batch_transactions.md` (434 lines)
+
+**Modified:**
+- `lib/zai_payment.rb` (added 2 lines)
+- `lib/zai_payment/response.rb` (added "batches" key)
+- `readme.md` (added sections and examples)
+
+**Total:** 1,325+ lines of code, tests, and documentation added.
+
+## No Linter Errors
+
+All files pass linting checks with no errors or warnings.
+

data/RESPONSE_FORMAT_CORRECTION.md

@@ -0,0 +1,75 @@
+# Batch Transactions API Response Correction
+
+## Response Format for PATCH /batches/:id/transaction_states
+
+### ✅ Correct Response Format
+
+The actual API response for `PATCH /batches/:id/transaction_states` contains:
+
+```json
+{
+  "aggregated_jobs_uuid": "c1cbc502-9754-42fd-9731-2330ddd7a41f",
+  "msg": "1 jobs have been sent to the queue.",
+  "errors": []
+}
+```
+
+### Response Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `aggregated_jobs_uuid` | String | UUID identifying the batch of jobs sent to the queue |
+| `msg` | String | Success message indicating how many jobs were queued |
+| `errors` | Array | Array of any errors (typically empty on success) |
+
+### Ruby Usage Example
+
+```ruby
+response = ZaiPayment.batch_transactions.update_transaction_states(
+  'batch_id',
+  exported_ids: ['439970a2-e0a1-418e-aecf-6b519c115c55'],
+  state: 12700
+)
+
+# Access response data
+response.body['aggregated_jobs_uuid'] # => "c1cbc502-9754-42fd-9731-2330ddd7a41f"
+response.body['msg']                   # => "1 jobs have been sent to the queue."
+response.body['errors']                # => []
+
+# Check for success
+if response.success? && response.body['errors'].empty?
+  puts "Successfully queued #{response.body['msg']}"
+  puts "Job UUID: #{response.body['aggregated_jobs_uuid']}"
+end
+```
+
+### Multiple Transactions
+
+When processing multiple transactions, the message reflects the count:
+
+```ruby
+response = ZaiPayment.batch_transactions.update_transaction_states(
+  'batch_id',
+  exported_ids: ['id1', 'id2', 'id3'],
+  state: 12000
+)
+
+response.body['msg'] # => "3 jobs have been sent to the queue."
+```
+
+## Updated Files
+
+All documentation and specs have been updated to reflect the correct response format:
+
+1. ✅ `lib/zai_payment/resources/batch_transaction.rb` - YARD documentation
+2. ✅ `spec/zai_payment/resources/batch_transaction_spec.rb` - Test expectations
+3. ✅ `examples/batch_transactions.md` - Example code
+4. ✅ `docs/batch_transactions.md` - Technical documentation
+
+## Key Points
+
+- The response is **asynchronous** - jobs are queued for processing
+- The `aggregated_jobs_uuid` can be used to track the batch of jobs
+- Check the `errors` array to ensure no errors occurred
+- The `msg` field contains a human-readable description of what was queued
+

data/badges/coverage.json

@@ -1 +1 @@
-{"schemaVersion": 1, "label": "coverage", "message": "97.39%", "color": "brightgreen"}
+{"schemaVersion": 1, "label": "coverage", "message": "97.47%", "color": "brightgreen"}

data/changelog.md

@@ -1,5 +1,88 @@
 ## [Released]
 
+## [2.7.0] - 2025-11-04
+
+### Added
+- **Batch Transactions Resource**: Complete batch transaction management for testing in prelive environment 🔄
+  - `ZaiPayment.batch_transactions.export_transactions` - Export pending transactions to batched state
+  - `ZaiPayment.batch_transactions.process_to_bank_processing(batch_id, exported_ids:)` - Move batch to bank_processing state
+  - `ZaiPayment.batch_transactions.process_to_successful(batch_id, exported_ids:)` - Complete batch processing (triggers webhooks)
+  - `ZaiPayment.batch_transactions.show_batches` - List all batches
+  - `ZaiPayment.batch_transactions.show_batch(batch_id)` - Get specific batch details
+  - `ZaiPayment.batch_transactions.show_transactions(batch_id, limit:, offset:)` - List transactions in a batch with pagination
+  - Prelive-only endpoints for testing transaction processing workflows
+  - Full RSpec test suite with 20+ test examples
+  - Comprehensive documentation in `docs/batch_transactions.md`
+  - Practical examples in `examples/batch_transactions.md`
+
+- **Wallet Account Resource**: Complete wallet account management for Australian payments 💼
+  - `ZaiPayment.wallet_accounts.show(wallet_account_id)` - Get wallet account details including balance
+  - `ZaiPayment.wallet_accounts.show_user(wallet_account_id)` - Get user associated with wallet account
+  - `ZaiPayment.wallet_accounts.show_npp_details(wallet_account_id)` - Get NPP (New Payments Platform) details including PayID
+  - `ZaiPayment.wallet_accounts.show_bpay_details(wallet_account_id)` - Get BPay details including biller code and reference
+  - `ZaiPayment.wallet_accounts.pay_bill(wallet_account_id, account_id:, amount:, reference_id:)` - Pay bills via BPay from wallet
+  - Support for checking wallet balances before transactions
+  - Support for NPP payments with PayID
+  - Support for BPay bill payments
+  - Validation for payment amounts and reference IDs
+  - Full RSpec test suite with 35+ test examples across 5 describe blocks
+  - Comprehensive documentation in `docs/wallet_accounts.md`
+  - Practical examples in `examples/wallet_accounts.md`
+
+### Documentation
+- **Batch Transactions Guide** (`docs/batch_transactions.md`):
+  - Complete guide for all 6 batch transaction endpoints
+  - Detailed workflow for simulating batch processing
+  - State transition diagrams and examples
+  - Error handling patterns for batch operations
+  - Important notes about prelive-only usage
+  
+- **Batch Transactions Examples** (`examples/batch_transactions.md`):
+  - Export transactions examples (3 examples)
+  - Process to bank_processing examples (3 examples)
+  - Process to successful examples (3 examples)
+  - Show batches and transactions examples (6 examples)
+  - Complete workflow patterns
+  - Rails integration examples
+  - Webhook simulation workflows
+
+- **Wallet Accounts Guide** (`docs/wallet_accounts.md`):
+  - Complete guide for all 5 wallet account endpoints
+  - Balance checking and payment workflows
+  - NPP PayID integration examples
+  - BPay bill payment patterns
+  - Validation rules and error handling
+  - Four comprehensive use cases:
+    - Balance verification before payment
+    - Multiple bill payments workflow
+    - User verification for payments
+    - Disbursement status monitoring
+
+- **Wallet Accounts Examples** (`examples/wallet_accounts.md`):
+  - Show wallet account examples (3 examples)
+  - Show user examples (3 examples)
+  - NPP details examples
+  - BPay details examples
+  - Pay bill examples (3 examples)
+  - Three common patterns:
+    - Complete payment workflow
+    - Wallet payment service class
+    - Rails controller integration
+
+### Enhanced
+- **Response Class**: Added `disbursements` to `RESPONSE_DATA_KEYS` for automatic data extraction
+  - `response.data` now properly extracts disbursement objects from pay_bill responses
+  - Consistent with other resource response handling
+
+### Updated
+- **README.md**: 
+  - Added Wallet Accounts to features section
+  - Added Batch Transactions documentation links
+  - Updated roadmap to mark Payments as Done
+  - Added quick start examples for wallet account operations
+
+**Full Changelog**: https://github.com/Sentia/zai-payment/compare/v2.6.1...v2.7.0
+
 ## [2.6.1] - 2025-11-03
 
 ### Changed

data/docs/batch_transactions.md

@@ -0,0 +1,340 @@
+# Batch Transactions (Prelive Only)
+
+## Overview
+
+The Batch Transaction resource provides methods to simulate batch transaction processing in the prelive environment. These endpoints are designed for testing and allow you to move transactions through different states of the batch processing lifecycle.
+
+**Important:** These endpoints are only available when the gem is configured for the `:prelive` environment. Attempting to use them in production will raise a `ConfigurationError`.
+
+## When to Use
+
+Use the batch transaction endpoints when you need to:
+
+1. Test the full lifecycle of batch transaction processing
+2. Simulate bank processing states in your test environment
+3. Trigger batch transaction webhooks for testing webhook handlers
+4. Verify your application's handling of different batch transaction states
+
+## Authentication & Configuration
+
+Ensure your configuration uses the prelive environment:
+
+```ruby
+ZaiPayment.configure do |config|
+  config.environment = :prelive  # Required!
+  config.client_id = 'your_client_id'
+  config.client_secret = 'your_client_secret'
+  config.scope = 'your_scope'
+end
+```
+
+## Resource Access
+
+Access the batch transaction resource through the main module:
+
+```ruby
+batch_transactions = ZaiPayment.batch_transactions
+```
+
+## The Batch Transaction Lifecycle
+
+In prelive, batch transactions go through these states:
+
+1. **pending** → Initial state when a batch transaction is created
+2. **batched** → Transactions grouped into a batch (via `export_transactions`)
+3. **bank_processing** (state 12700) → Batch is being processed by the bank
+4. **successful** (state 12000) → Processing complete, webhook triggered
+
+## Method Reference
+
+### `export_transactions`
+
+Moves all pending batch transactions to the "batched" state and returns them with their assigned `batch_id`.
+
+**Signature:**
+```ruby
+export_transactions() → Response
+```
+
+**Returns:**
+- `Response` object with transactions array
+- Each transaction includes: `id`, `batch_id`, `status`, `type`, `type_method`
+
+**Raises:**
+- `ConfigurationError` - if not in prelive environment
+
+**Example:**
+```ruby
+response = ZaiPayment.batch_transactions.export_transactions
+
+response.data
+# => [
+#   {
+#     "id" => "439970a2-e0a1-418e-aecf-6b519c115c55",
+#     "batch_id" => "dabcfd50-bf5a-0138-7b40-0a58a9feac03",
+#     "status" => "batched",
+#     "type" => "payment_funding",
+#     "type_method" => "credit_card"
+#   }
+# ]
+```
+
+**Note:** Store the returned `batch_id` - you'll need it for the next steps. Transaction IDs may be cleared after 24 hours in prelive.
+
+---
+
+### `update_transaction_states`
+
+Updates the state of one or more batch transactions within a batch.
+
+**Signature:**
+```ruby
+update_transaction_states(batch_id, exported_ids:, state:) → Response
+```
+
+**Parameters:**
+- `batch_id` (String) - The batch ID from `export_transactions` response
+- `exported_ids` (Array<String>) - Array of transaction IDs to update
+- `state` (Integer) - Target state code: `12700` (bank_processing) or `12000` (successful)
+
+**Returns:**
+- `Response` object with `aggregated_jobs_uuid`, `msg`, and `errors` array
+
+**Raises:**
+- `ConfigurationError` - if not in prelive environment
+- `ValidationError` - if batch_id is blank
+- `ValidationError` - if exported_ids is nil, empty, not an array, or contains nil/empty values
+- `ValidationError` - if state is not 12700 or 12000
+
+**Example:**
+```ruby
+response = ZaiPayment.batch_transactions.update_transaction_states(
+  'batch_id',
+  exported_ids: ['439970a2-e0a1-418e-aecf-6b519c115c55'],
+  state: 12700
+)
+
+response.body
+# => {
+#   "aggregated_jobs_uuid" => "c1cbc502-9754-42fd-9731-2330ddd7a41f",
+#   "msg" => "1 jobs have been sent to the queue.",
+#   "errors" => []
+# }
+```
+
+---
+
+### `process_to_bank_processing`
+
+Convenience method to move transactions to the "bank_processing" state (12700).
+
+**Signature:**
+```ruby
+process_to_bank_processing(batch_id, exported_ids:) → Response
+```
+
+**Parameters:**
+- `batch_id` (String) - The batch ID from `export_transactions` response
+- `exported_ids` (Array<String>) - Array of transaction IDs to update
+
+**Returns:**
+- `Response` object with `aggregated_jobs_uuid`, `msg`, and `errors` (12700)
+
+**Raises:**
+- Same as `update_transaction_states`
+
+**Example:**
+```ruby
+response = ZaiPayment.batch_transactions.process_to_bank_processing(
+  'batch_id',
+  exported_ids: ['transaction_id_1', 'transaction_id_2']
+)
+```
+
+**Note:** This is equivalent to calling `update_transaction_states` with `state: 12700`.
+
+---
+
+### `process_to_successful`
+
+Convenience method to move transactions to the "successful" state (12000). This triggers batch transaction webhooks.
+
+**Signature:**
+```ruby
+process_to_successful(batch_id, exported_ids:) → Response
+```
+
+**Parameters:**
+- `batch_id` (String) - The batch ID from `export_transactions` response
+- `exported_ids` (Array<String>) - Array of transaction IDs to update
+
+**Returns:**
+- `Response` object with `aggregated_jobs_uuid`, `msg`, and `errors` (12000)
+
+**Raises:**
+- Same as `update_transaction_states`
+
+**Example:**
+```ruby
+response = ZaiPayment.batch_transactions.process_to_successful(
+  'batch_id',
+  exported_ids: ['transaction_id_1']
+)
+
+# This will trigger a batch_transactions webhook
+```
+
+**Note:** This is equivalent to calling `update_transaction_states` with `state: 12000`.
+
+---
+
+## Complete Workflow Example
+
+Here's the typical workflow for testing batch transactions in prelive:
+
+```ruby
+# Step 1: Export pending transactions
+export_response = ZaiPayment.batch_transactions.export_transactions
+
+batch_id = export_response.data.first['batch_id']
+transaction_ids = export_response.data.map { |t| t['id'] }
+
+puts "Exported #{transaction_ids.length} transactions to batch #{batch_id}"
+
+# Step 2: Move to bank_processing state
+processing_response = ZaiPayment.batch_transactions.process_to_bank_processing(
+  batch_id,
+  exported_ids: transaction_ids
+)
+
+puts "Transactions moved to bank_processing (12700)"
+
+# Step 3: Move to successful state (triggers webhook)
+success_response = ZaiPayment.batch_transactions.process_to_successful(
+  batch_id,
+  exported_ids: transaction_ids
+)
+
+puts "Transactions completed successfully (12000)"
+puts "Webhook should now be triggered"
+```
+
+## State Codes
+
+| Code | State | Description |
+|------|-------|-------------|
+| 12700 | bank_processing | Transactions are being processed by the bank |
+| 12000 | successful | Final state - processing complete, webhooks triggered |
+
+## Error Handling
+
+### ConfigurationError
+
+Raised when attempting to use batch transaction endpoints outside of prelive:
+
+```ruby
+ZaiPayment.configure do |config|
+  config.environment = :production  # Wrong environment!
+end
+
+begin
+  ZaiPayment.batch_transactions.export_transactions
+rescue ZaiPayment::Errors::ConfigurationError => e
+  puts e.message
+  # => "Batch transaction endpoints are only available in prelive environment. 
+  #     Current environment: production"
+end
+```
+
+### ValidationError
+
+Raised when parameters are invalid:
+
+```ruby
+# Blank batch_id
+ZaiPayment.batch_transactions.process_to_bank_processing(
+  '',
+  exported_ids: ['id']
+)
+# => ValidationError: batch_id is required and cannot be blank
+
+# Empty exported_ids
+ZaiPayment.batch_transactions.process_to_bank_processing(
+  'batch_id',
+  exported_ids: []
+)
+# => ValidationError: exported_ids is required and must be a non-empty array
+
+# exported_ids contains nil
+ZaiPayment.batch_transactions.process_to_bank_processing(
+  'batch_id',
+  exported_ids: ['valid_id', nil]
+)
+# => ValidationError: exported_ids cannot contain nil or empty values
+
+# Invalid state code
+ZaiPayment.batch_transactions.update_transaction_states(
+  'batch_id',
+  exported_ids: ['id'],
+  state: 99999
+)
+# => ValidationError: state must be 12700 (bank_processing) or 12000 (successful), got: 99999
+```
+
+## Testing Webhooks
+
+The `process_to_successful` method triggers batch transaction webhooks, allowing you to test your webhook handlers:
+
+```ruby
+# Set up webhook handler to receive batch_transactions events
+# Then complete the batch transaction flow:
+
+export_response = ZaiPayment.batch_transactions.export_transactions
+batch_id = export_response.data.first['batch_id']
+transaction_ids = export_response.data.map { |t| t['id'] }
+
+# Process through states
+ZaiPayment.batch_transactions.process_to_bank_processing(batch_id, exported_ids: transaction_ids)
+ZaiPayment.batch_transactions.process_to_successful(batch_id, exported_ids: transaction_ids)
+
+# Your webhook handler should now receive the batch_transactions webhook
+```
+
+## Querying Batch Transactions
+
+After exporting and processing transactions, you can query them using the item's transaction endpoints:
+
+```ruby
+# List transactions for an item
+item_id = 'your_item_id'
+response = ZaiPayment.items.list_transactions(item_id)
+
+# List batch transactions for an item
+response = ZaiPayment.items.list_batch_transactions(item_id)
+```
+
+You can also query batch transactions directly via the API using cURL:
+
+```bash
+curl https://test.api.promisepay.com/batch_transactions/dabcfd50-bf5a-0138-7b40-0a58a9feac03 \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
+## Important Notes
+
+1. **Prelive Only**: These endpoints only work in prelive environment
+2. **24-Hour Limit**: Transaction IDs may be cleared after 24 hours in prelive
+3. **Webhook Trigger**: Only the successful state (12000) triggers webhooks
+4. **Batch ID Required**: You must save the `batch_id` from `export_transactions` for subsequent calls
+5. **Array Support**: You can process multiple transactions at once by passing multiple IDs
+
+## Related Resources
+
+- [Items](./items.md) - For creating items that generate transactions
+- [Webhooks](./webhooks.md) - For handling batch transaction webhooks
+- [Webhook Security](./webhook_security_quickstart.md) - For securing your webhook endpoints
+
+## API Reference
+
+For more details on the underlying API endpoints, see the [Zai API Documentation](https://developer.hellozai.com/reference).
+