tigerbeetle-node 0.5.2 → 0.8.1

package/README.md

@@ -10,29 +10,16 @@ The following steps will install the `tigerbeetle-node` module to your current w
 
 > Your operating system should be Linux (kernel >= v5.6) or macOS. Windows support is not yet available but is in the works.
 
-> Ensure you are not currently in the project (tigerbeetle-node) directory, but the `parent` directory instead;
-     
-### YARN Package Manager
-
-```sh
+### YARN Package Manager Installation
+```shell
 yarn add tigerbeetle-node
 ```
 or
-
-### NPM Package Manager 
-```sh
+### NPM Package Manager Installation
+```shell
 npm install tigerbeetle-node
 ```
 
-**Development**
-
-Follow these steps to get up and running when cloning the repo:
-
-```sh
-git clone --recurse-submodules https://github.com/coilhq/tigerbeetle-node.git
-yarn
-```
-
 ## Usage
 A client needs to be configured with a `cluster_id` and `replica_addresses`. 
 This instantiates the client where memory is allocated to internally buffer events to be sent. 
@@ -42,7 +29,7 @@ Future releases will allow multiple client instantiations.
 import { createClient } from 'tigerbeetle-node'
 
 const client = createClient({
-  cluster_id: 1,
+  cluster_id: 0,
   replica_addresses: ['3001', '3002', '3003']
 })
 ```
@@ -55,15 +42,15 @@ This is reflected in the below function interfaces where each one takes in an ar
 ```js
 const account = {
     id: 137n, // u128
-    user_data: 0n, // u128, opaque third-party identifier to link this account (many-to-one) to an external entity:
+    user_data: 0n, // u128, opaque third-party identifier to link this account to an external entity:
     reserved: Buffer.alloc(48, 0), // [48]u8
-    unit: 1,   // u16, unit of value
+    ledger: 1,   // u32, ledger value
     code: 718, // u16, a chart of accounts code describing the type of account (e.g. clearing, settlement)
-    flags: 0,  // u32
-    debits_reserved: 0n,  // u64
-    debits_accepted: 0n,  // u64
-    credits_reserved: 0n, // u64
-    credits_accepted: 0n, // u64
+    flags: 0,  // u16
+    debits_pending: 0n,  // u64
+    debits_posted: 0n,  // u64
+    credits_pending: 0n, // u64
+    credits_posted: 0n, // u64
     timestamp: 0n, // u64, Reserved: This will be set by the server.
 }
 
@@ -88,7 +75,7 @@ The `flags` on an account provide a way for you to enforce policies by toggling
 |----------|----------------------------------|-----------------------------------------|
 | `linked` | `debits_must_not_exceed_credits` | `credits_must_not_exceed_debits` |
 
-The creation of an account can be linked to the successful creation of another by setting the `linked` flag (see [linked events](#linked-events)). By setting `debits_must_not_exceed_credits`, then any transfer such that `debits_accepted + debits_reserved + amount > credit_accepted` will fail. Similarly for `credits_must_not_exceed_debits`.
+The creation of an account can be linked to the successful creation of another by setting the `linked` flag (see [linked events](#linked-events)). By setting `debits_must_not_exceed_credits`, then any transfer such that `debits_posted + debits_pending + amount > credits_posted` will fail. Similarly for `credits_must_not_exceed_debits`.
 ```js
   enum CreateAccountFlags {
     linked = (1 << 0),
@@ -100,7 +87,7 @@ The creation of an account can be linked to the successful creation of another b
   flags |= CreateAccountFlags.debits_must_not_exceed_credits
 ```
 
-### Account lookup
+### Account Lookup
 
 The `id` of the account is used for lookups. Only matched accounts are returned.
 ```js
@@ -112,80 +99,78 @@ The `id` of the account is used for lookups. Only matched accounts are returned.
    *   id: 137n,
    *   user_data: 0n,
    *   reserved: Buffer,
-   *   unit: 1,
+   *   ledger: 1,
    *   code: 718,
    *   flags: 0,
-   *   debits_reserved: 0n,
-   *   debits_accepted: 0n,
-   *   credits_reserved: 0n,
-   *   credits_accepted: 0n,
+   *   debits_pending: 0n,
+   *   debits_posted: 0n,
+   *   credits_pending: 0n,
+   *   credits_posted: 0n,
    *   timestamp: 1623062009212508993n,
    * }]
    */
 ```
 
-### Creating a transfer
+### Creating a Transfer
 
 This creates a journal entry between two accounts.
 ```js
 const transfer = {
     id: 1n, // u128
+    // Double-entry accounting:
     debit_account_id: 1n,  // u128
     credit_account_id: 2n, // u128
-    user_data: 0n, // u128, opaque third-party identifier to link this transfer (many-to-one) to an external entity 
-    reserved: Buffer.alloc(32, 0), // two-phase condition can go in here
-    timeout: 0n, // u64, in nano-seconds. 
-    code: 1,  // u32, a chart of accounts code describing the reason for the transfer (e.g. deposit, settlement)
-    flags: 0, // u32
+    // Opaque third-party identifier to link this transfer to an external entity:
+    user_data: 0n, // u128  
+    reserved: 0n, // u128
+    // Timeout applicable for a pending/2-phase transfer:
+    timeout: 0n, // u64, in nano-seconds.
+    // Collection of accounts usually grouped by the currency: 
+    // You can't transfer money between accounts with different ledgers:
+    ledger: 720,  // u32, ledger for transfer (e.g. currency).
+    // Chart of accounts code describing the reason for the transfer:
+    code: 1,  // u16, (e.g. deposit, settlement)
+    flags: 0, // u16
     amount: 10n, // u64
     timestamp: 0n, //u64, Reserved: This will be set by the server.
 }
-
 const errors = await client.createTransfers([transfer])
 ```
-Two-phase transfers are supported natively by toggling the appropriate flag. TigerBeetle will then adjust the `credits_reserved` and `debits_reserved` fields of the appropriate accounts. A corresponding commit transfer then needs to be sent to accept or reject the transfer.
-| bit 0    | bit 1              | bit 2            |
-|----------|--------------------|------------------|
-| `linked` | `two_phase_commit` | `condition`      |
+Two-phase transfers are supported natively by toggling the appropriate flag. TigerBeetle will then adjust the `credits_pending` and `debits_pending` fields of the appropriate accounts. A corresponding commit transfer then needs to be sent to accept or reject the transfer.
 
-The `condition` flag signals to TigerBeetle that a 256-bit cryptographic condition will be supplied in the `reserved` field. This will be validated against a supplied pre-image when the transfer is committed. Transfers within a batch may also be linked (see [linked events](#linked-events)).
+Transfers within a batch may also be linked (see [linked events](#linked-events)).
 ```js
-  enum CreateTransferFlags {
-    linked = (1 << 0>>),
-    two_phase_commit = (1 << 1),
-    condition = (1 << 2)
+  enum TransferFlags {
+    linked = (1 << 0),
+    pending = (1 << 1),
+    post_pending_transfer = (1 << 2),
+    void_pending_transfer = (1 << 3)
   }
-
-// two-phase transfer
+  
+  // Two-phase transfer (pending):
   let flags = 0n
-  flags |= TransferFlags.two_phase_commit
+  flags |= TransferFlags.pending
 
-  // two-phase transfer with condition supplied in `reserved`
+  // Linked two-phase transfer (pending):
   let flags = 0n
-  flags |= TransferFlags.two_phase_commit
-  flags |= TransferFlags.condition
+  flags |= TransferFlags.linked
+  flags |= TransferFlags.pending
 ```
 
-### Committing a transfer
-
-This is used to commit a two-phase transfer.
-| bit 0    | bit 1    | bit 2      |
-|----------|----------|------------|
-| `linked` | `reject` | `preimage` |
+### Post a Pending Transfer (2-Phase)
 
-By default (`flags = 0`), it will accept the transfer. TigerBeetle will atomically rollback the changes to `debits_reserved` and `credits_reserved` of the appropriate accounts and apply them to the `debits_accepted` and `credits_accepted` balances. If the `preimage` bit is set then TigerBeetle will look for it in the `reserved` field and validate it against the `condition` from the associated transfer. If this validation fails, or `reject` is set, then the changes to the `reserved` balances are atomically rolled back.
+With `flags = post_pending_transfer`, TigerBeetle will accept the transfer. TigerBeetle will atomically rollback the changes to `debits_pending` and `credits_pending` of the appropriate accounts and apply them to the `debits_posted` and `credits_posted` balances.
 ```js
-const commit = {
-    id: 1n,   // u128, must correspond to the transfer id
-    reserved: Buffer.alloc(32, 0), // [32]u8
-    code: 1,  // u32, accounting system code to identify type of transfer
-    flags: 0, // u32
+const post = {
+    id: 2n, // u128, must correspond to the transfer id
+    pending_id: 1n, // u128, id of the pending transfer
+    flags: TransferFlags.post_pending_transfer, // to void, use [void_pending_transfer]
     timestamp: 0n, // u64, Reserved: This will be set by the server.
 }
-const errors = await client.commitTransfers([commit])
+const errors = await client.createTransfers([post])
 ```
 
-### Linked events
+### Linked Events
 
 When the `linked` flag is specified for the `createAccount`, `createTransfer`, `commitTransfer` event, it links an event with the next event in the batch, to create a chain of events, of arbitrary length, which all succeed or fail together. The tail of a chain is denoted by the first event without this flag. The last event in a batch may therefore never have the `linked` flag set as this would leave a chain open-ended. Multiple chains or individual events may coexist within a batch to succeed or fail independently. Events within a chain are executed within order, or are rolled back on error, so that the effect of each event in the chain is visible to the next, and so that the chain is either visible or invisible as a unit to subsequent events after the chain. The event that was the first to break the chain will have a unique error result. Other events in the chain will have their error result set to `linked_event_failed`.
 
@@ -194,10 +179,10 @@ let batch = []
 let linkedFlag = 0
 linkedFlag |= CreateTransferFlags.linked
 
-// An individual transfer (successful)
+// An individual transfer (successful):
 batch.push({ id: 1n, ... })
 
-// A chain of 4 transfers (the last transfer in the chain closes the chain with linked=false)
+// A chain of 4 transfers (the last transfer in the chain closes the chain with linked=false):
 batch.push({ id: 2n, ..., flags: linkedFlag }) // Commit/rollback.
 batch.push({ id: 3n, ..., flags: linkedFlag }) // Commit/rollback.
 batch.push({ id: 2n, ..., flags: linkedFlag }) // Fail with exists
@@ -207,11 +192,11 @@ batch.push({ id: 4n, ..., flags: 0 })          // Fail without committing.
 // This should not see any effect from the failed chain above.
 batch.push({ id: 2n, ..., flags: 0 })
 
-// A chain of 2 transfers (the first transfer fails the chain)
+// A chain of 2 transfers (the first transfer fails the chain):
 batch.push({ id: 2n, ..., flags: linkedFlag })
 batch.push({ id: 3n, ..., flags: 0 })
 
-// A chain of 2 transfers (successful)
+// A chain of 2 transfers (successful):
 batch.push({ id: 3n, ..., flags: linkedFlag })
 batch.push({ id: 4n, ..., flags: 0 })
 
@@ -219,13 +204,47 @@ const errors = await client.createTransfers(batch)
 
 /**
  * [
- *  { index: 1, error: 1 }, // linked_event_failed
- *  { index: 2, error: 1 }, // linked_event_failed
- *  { index: 3, error: 2 }, // exists
- *  { index: 4, error: 1 }, // linked_event_failed
+ *  { index: 1, error: 1 },  // linked_event_failed
+ *  { index: 2, error: 1 },  // linked_event_failed
+ *  { index: 3, error: 25 }, // exists
+ *  { index: 4, error: 1 },  // linked_event_failed
  * 
- *  { index: 6, error: 7 }, // exists_with_different_flags
- *  { index: 7, error: 1 }, // linked_event_failed
+ *  { index: 6, error: 17 }, // exists_with_different_flags
+ *  { index: 7, error: 1 },  // linked_event_failed
  * ]
  */
 ```
+
+### Development
+
+Follow these steps to get up and running when cloning the repo:
+```shell
+git clone --recurse-submodules https://github.com/coilhq/tigerbeetle-node.git
+cd tigerbeetle-node/
+yarn install --immutable
+```
+
+Build locally using `yarn`:
+```shell
+# Run the following from this directory:
+yarn && yarn build
+```
+
+* **Please note: `yarn clean` will remove Zig and NodeAPI C headers, which mean you need to run:**
+```shell
+./scripts/postinstall.sh #Install Zig and NodeJS C Headers
+```
+
+***Yarn - Run Test***
+Ensure TigerBeetle (`init` & `start`) is running on the port configured in `test.ts`, then run:
+```shell
+./tigerbeetle init --cluster=1 --replica=0 --directory=.
+./tigerbeetle start --cluster=1 --replica=0 --directory=. --addresses=3001
+yarn test
+```
+
+***Yarn - Run Benchmark***
+Run the benchmark (The `benchmark` will automatically start TigerBeetle on port `3001` _(single replica)_:
+```shell
+yarn benchmark
+```

package/dist/benchmark.js

@@ -5,46 +5,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert_1 = __importDefault(require("assert"));
 const _1 = require(".");
-const MAX_TRANSFERS = 1000000;
-const MAX_REQUEST_BATCH_SIZE = 10000;
-const IS_TWO_PHASE_COMMIT = false;
+const MAX_TRANSFERS = 51200;
+const MAX_REQUEST_BATCH_SIZE = 5120;
+const IS_TWO_PHASE_TRANSFER = false;
 const IS_RAW_REQUEST = false;
-const PREVIOUS_RAW_REQUEST_RESULT = IS_TWO_PHASE_COMMIT ? 300000 : 620000;
-const PREVIOUS_RESULT = IS_TWO_PHASE_COMMIT ? 150000 : 310000;
+const PREVIOUS_RAW_REQUEST_RESULT = IS_TWO_PHASE_TRANSFER ? 300000 : 620000;
+const PREVIOUS_RESULT = IS_TWO_PHASE_TRANSFER ? 150000 : 310000;
 const PREVIOUS_BENCHMARK = IS_RAW_REQUEST ? PREVIOUS_RAW_REQUEST_RESULT : PREVIOUS_RESULT;
 const TOLERANCE = 10;
 const client = _1.createClient({
-    cluster_id: 1,
+    cluster_id: 0,
     replica_addresses: ['3001']
 });
 const TRANSFER_SIZE = 128;
-const COMMIT_SIZE = 64;
 const Zeroed48Bytes = Buffer.alloc(48, 0);
-const Zeroed32Bytes = Buffer.alloc(32, 0);
 const accountA = {
     id: 137n,
     user_data: 0n,
     reserved: Zeroed48Bytes,
-    code: 0,
+    ledger: 1,
+    code: 1,
     flags: 0,
-    unit: 1,
-    debits_accepted: 0n,
-    debits_reserved: 0n,
-    credits_accepted: 0n,
-    credits_reserved: 0n,
+    debits_pending: 0n,
+    debits_posted: 0n,
+    credits_pending: 0n,
+    credits_posted: 0n,
     timestamp: 0n,
 };
 const accountB = {
     id: 138n,
     user_data: 0n,
     reserved: Zeroed48Bytes,
-    code: 0,
+    ledger: 1,
+    code: 1,
     flags: 0,
-    unit: 1,
-    debits_accepted: 0n,
-    debits_reserved: 0n,
-    credits_accepted: 0n,
-    credits_reserved: 0n,
+    debits_pending: 0n,
+    debits_posted: 0n,
+    credits_pending: 0n,
+    credits_posted: 0n,
     timestamp: 0n,
 };
 const rawCreateTransfers = async (batch) => {
@@ -63,46 +61,30 @@ const rawCreateTransfers = async (batch) => {
         }
     });
 };
-const rawCommitTransfers = async (batch) => {
-    return new Promise((resolve, reject) => {
-        const callback = (error, results) => {
-            if (error) {
-                reject(error);
-            }
-            resolve(results);
-        };
-        try {
-            client.rawRequest(_1.Operation.COMMIT_TRANSFER, batch, callback);
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-};
 const encodeTransfer = (transfer, offset, output) => {
-    assert_1.default(offset + TRANSFER_SIZE <= output.length);
+    assert_1.default(BigInt((offset + TRANSFER_SIZE)) <= BigInt(output.length), `Transfer ${transfer} exceeds buffer of ${output}!`);
     output.writeBigUInt64LE(transfer.id, offset);
     output.writeBigUInt64LE(transfer.debit_account_id, offset + 16);
     output.writeBigUInt64LE(transfer.credit_account_id, offset + 32);
+    output.writeBigUInt64LE(transfer.user_data, offset + 48);
+    output.writeBigUInt64LE(transfer.reserved, offset + 64);
+    output.writeBigUInt64LE(transfer.pending_id, offset + 80);
     output.writeBigUInt64LE(transfer.timeout, offset + 96);
-    output.writeUInt32LE(transfer.code, offset + 104);
-    output.writeUInt32LE(transfer.flags, offset + 108);
+    output.writeUInt32LE(transfer.ledger, offset + 104);
+    output.writeUInt32LE(transfer.code, offset + 108);
+    output.writeUInt32LE(transfer.flags, offset + 110);
     output.writeBigUInt64LE(transfer.amount, offset + 112);
     output.writeBigUInt64LE(transfer.timestamp, offset + 120);
 };
-const encodeCommit = (commit, offset, output) => {
-    assert_1.default(offset + COMMIT_SIZE <= output.length);
-    output.writeBigUInt64LE(commit.id, offset);
-};
-const runBenchmarkRawReqeust = async () => {
+const runBenchmarkRawRequest = async () => {
     assert_1.default(MAX_TRANSFERS % MAX_REQUEST_BATCH_SIZE === 0, "The raw request benchmark requires MAX_TRANSFERS to be a multiple of MAX_REQUEST_BATCH_SIZE");
-    console.log(`pre-allocating ${MAX_TRANSFERS} transfers and commits...`);
+    console.log(`pre-allocating ${MAX_TRANSFERS} transfers and posts...`);
     const transfers = [];
-    const commits = [];
+    const posts = [];
     let count = 0;
     while (count < MAX_TRANSFERS) {
         const transferBatch = Buffer.alloc(MAX_REQUEST_BATCH_SIZE * TRANSFER_SIZE, 0);
-        const commitBatch = Buffer.alloc(MAX_REQUEST_BATCH_SIZE * COMMIT_SIZE, 0);
+        const postTransferBatch = Buffer.alloc(MAX_REQUEST_BATCH_SIZE * TRANSFER_SIZE, 0);
         for (let i = 0; i < MAX_REQUEST_BATCH_SIZE; i++) {
             if (count === MAX_TRANSFERS)
                 break;
@@ -111,27 +93,38 @@ const runBenchmarkRawReqeust = async () => {
                 id: BigInt(count),
                 debit_account_id: accountA.id,
                 credit_account_id: accountB.id,
-                code: 0,
-                reserved: Zeroed32Bytes,
                 user_data: 0n,
-                flags: IS_TWO_PHASE_COMMIT ? _1.TransferFlags.two_phase_commit : 0,
+                reserved: 0n,
+                pending_id: 0n,
+                timeout: IS_TWO_PHASE_TRANSFER ? BigInt(2e9) : 0n,
+                ledger: 1,
+                code: 1,
+                flags: IS_TWO_PHASE_TRANSFER ? _1.TransferFlags.pending : 0,
                 amount: 1n,
-                timeout: IS_TWO_PHASE_COMMIT ? BigInt(2e9) : 0n,
                 timestamp: 0n,
             }, i * TRANSFER_SIZE, transferBatch);
-            if (IS_TWO_PHASE_COMMIT) {
-                encodeCommit({
-                    id: BigInt(count),
-                    reserved: Buffer.alloc(32, 0),
-                    code: 0,
-                    flags: 0,
+            if (IS_TWO_PHASE_TRANSFER) {
+                encodeTransfer({
+                    id: BigInt((MAX_TRANSFERS + count)),
+                    debit_account_id: accountA.id,
+                    credit_account_id: accountB.id,
+                    user_data: 0n,
+                    reserved: 0n,
+                    pending_id: BigInt(count),
+                    timeout: 0n,
+                    ledger: 1,
+                    code: 1,
+                    flags: _1.TransferFlags.post_pending_transfer,
+                    amount: 1n,
                     timestamp: 0n,
-                }, i * COMMIT_SIZE, commitBatch);
+                }, i * TRANSFER_SIZE, postTransferBatch);
             }
         }
         transfers.push(transferBatch);
-        if (IS_TWO_PHASE_COMMIT)
-            commits.push(commitBatch);
+        if (IS_TWO_PHASE_TRANSFER)
+            posts.push(postTransferBatch);
+        if (count % 100)
+            console.log(`${Number((count / MAX_TRANSFERS) * 100).toFixed(1)}%`);
     }
     assert_1.default(count === MAX_TRANSFERS);
     console.log(`starting benchmark. MAX_TRANSFERS=${MAX_TRANSFERS} REQUEST_BATCH_SIZE=${MAX_REQUEST_BATCH_SIZE} NUMBER_OF_BATCHES=${transfers.length}`);
@@ -140,16 +133,16 @@ const runBenchmarkRawReqeust = async () => {
     const start = Date.now();
     for (let i = 0; i < transfers.length; i++) {
         const ms1 = Date.now();
-        const transferResults = await rawCreateTransfers(transfers[i]);
-        assert_1.default(transferResults.length === 0);
+        const transferErrors = await rawCreateTransfers(transfers[i]);
+        assert_1.default(transferErrors.length === 0);
         const ms2 = Date.now();
         const createTransferLatency = ms2 - ms1;
         if (createTransferLatency > maxCreateTransfersLatency) {
             maxCreateTransfersLatency = createTransferLatency;
         }
-        if (IS_TWO_PHASE_COMMIT) {
-            const commitResults = await rawCommitTransfers(commits[i]);
-            assert_1.default(commitResults.length === 0);
+        if (IS_TWO_PHASE_TRANSFER) {
+            const commitErrors = await rawCreateTransfers(posts[i]);
+            assert_1.default(commitErrors.length === 0);
             const ms3 = Date.now();
             const commitTransferLatency = ms3 - ms2;
             if (commitTransferLatency > maxCommitTransfersLatency) {
@@ -165,42 +158,51 @@ const runBenchmarkRawReqeust = async () => {
     };
 };
 const runBenchmark = async () => {
-    console.log(`pre-allocating ${MAX_TRANSFERS} transfers and commits...`);
+    console.log(`pre-allocating ${MAX_TRANSFERS} transfers and posts...`);
     const transfers = [];
-    const commits = [];
+    const posts = [];
     let count = 0;
     while (count < MAX_TRANSFERS) {
-        const transferBatch = [];
-        const commitBatch = [];
+        const pendingBatch = [];
+        const postBatch = [];
         for (let i = 0; i < MAX_REQUEST_BATCH_SIZE; i++) {
             if (count === MAX_TRANSFERS)
                 break;
             count += 1;
-            transferBatch.push({
+            pendingBatch.push({
                 id: BigInt(count),
                 debit_account_id: accountA.id,
                 credit_account_id: accountB.id,
-                code: 0,
-                reserved: Zeroed32Bytes,
+                pending_id: 0n,
+                code: 1,
+                ledger: 1,
+                reserved: 0n,
                 user_data: 0n,
-                flags: IS_TWO_PHASE_COMMIT ? _1.TransferFlags.two_phase_commit : 0,
+                flags: IS_TWO_PHASE_TRANSFER ? _1.TransferFlags.pending : 0,
                 amount: 1n,
-                timeout: IS_TWO_PHASE_COMMIT ? BigInt(2e9) : 0n,
+                timeout: IS_TWO_PHASE_TRANSFER ? BigInt(2e9) : 0n,
                 timestamp: 0n,
             });
-            if (IS_TWO_PHASE_COMMIT) {
-                commitBatch.push({
-                    id: BigInt(count),
-                    reserved: Buffer.alloc(32, 0),
-                    code: 0,
-                    flags: 0,
+            if (IS_TWO_PHASE_TRANSFER) {
+                postBatch.push({
+                    id: BigInt(MAX_TRANSFERS + count),
+                    debit_account_id: accountA.id,
+                    credit_account_id: accountB.id,
+                    pending_id: BigInt(count),
+                    code: 1,
+                    ledger: 1,
+                    reserved: 0n,
+                    user_data: 0n,
+                    flags: IS_TWO_PHASE_TRANSFER ? _1.TransferFlags.post_pending_transfer : 0,
+                    amount: 1n,
+                    timeout: 0n,
                     timestamp: 0n,
                 });
             }
         }
-        transfers.push(transferBatch);
-        if (IS_TWO_PHASE_COMMIT)
-            commits.push(commitBatch);
+        transfers.push(pendingBatch);
+        if (IS_TWO_PHASE_TRANSFER)
+            posts.push(postBatch);
     }
     assert_1.default(count === MAX_TRANSFERS);
     console.log(`starting benchmark. MAX_TRANSFERS=${MAX_TRANSFERS} REQUEST_BATCH_SIZE=${MAX_REQUEST_BATCH_SIZE} NUMBER_OF_BATCHES=${transfers.length}`);
@@ -209,16 +211,16 @@ const runBenchmark = async () => {
     const start = Date.now();
     for (let i = 0; i < transfers.length; i++) {
         const ms1 = Date.now();
-        const transferResults = await client.createTransfers(transfers[i]);
-        assert_1.default(transferResults.length === 0);
+        const transferErrors = await client.createTransfers(transfers[i]);
+        assert_1.default(transferErrors.length === 0);
         const ms2 = Date.now();
         const createTransferLatency = ms2 - ms1;
         if (createTransferLatency > maxCreateTransfersLatency) {
             maxCreateTransfersLatency = createTransferLatency;
         }
-        if (IS_TWO_PHASE_COMMIT) {
-            const commitResults = await client.commitTransfers(commits[i]);
-            assert_1.default(commitResults.length === 0);
+        if (IS_TWO_PHASE_TRANSFER) {
+            const commitErrors = await client.createTransfers(posts[i]);
+            assert_1.default(commitErrors.length === 0);
             const ms3 = Date.now();
             const commitTransferLatency = ms3 - ms2;
             if (commitTransferLatency > maxCommitTransfersLatency) {
@@ -238,18 +240,18 @@ const main = async () => {
     await client.createAccounts([accountA, accountB]);
     const accountResults = await client.lookupAccounts([accountA.id, accountB.id]);
     assert_1.default(accountResults.length === 2);
-    assert_1.default(accountResults[0].debits_accepted === 0n);
-    assert_1.default(accountResults[1].debits_accepted === 0n);
-    const benchmark = IS_RAW_REQUEST ? await runBenchmarkRawReqeust() : await runBenchmark();
+    assert_1.default(accountResults[0].debits_posted === 0n);
+    assert_1.default(accountResults[1].debits_posted === 0n);
+    const benchmark = IS_RAW_REQUEST ? await runBenchmarkRawRequest() : await runBenchmark();
     const accounts = await client.lookupAccounts([accountA.id, accountB.id]);
     const result = Math.floor((1000 * MAX_TRANSFERS) / benchmark.ms);
     console.log("=============================");
-    console.log(`${IS_TWO_PHASE_COMMIT ? 'two-phase ' : ''}transfers per second: ${result}`);
+    console.log(`${IS_TWO_PHASE_TRANSFER ? 'two-phase ' : ''}transfers per second: ${result}`);
     console.log(`create transfers max p100 latency per 10 000 transfers = ${benchmark.maxCreateTransfersLatency}ms`);
     console.log(`commit transfers max p100 latency per 10 000 transfers = ${benchmark.maxCommitTransfersLatency}ms`);
     assert_1.default(accounts.length === 2);
-    assert_1.default(accounts[0].debits_accepted === BigInt(MAX_TRANSFERS));
-    assert_1.default(accounts[1].credits_accepted === BigInt(MAX_TRANSFERS));
+    assert_1.default(accounts[0].debits_posted === BigInt(MAX_TRANSFERS));
+    assert_1.default(accounts[1].credits_posted === BigInt(MAX_TRANSFERS));
     if (result < PREVIOUS_BENCHMARK * (100 - TOLERANCE) / 100) {
         console.warn(`There has been a performance regression. Previous benchmark=${PREVIOUS_BENCHMARK}`);
     }