tigerbeetle-node 0.9.0 → 0.11.0

package/README.md

@@ -1,5 +1,5 @@
 # tigerbeetle-node
-[TigerBeetle](https://github.com/coilhq/tigerbeetle) client for Node.js.
+[TigerBeetle](https://github.com/tigerbeetledb/tigerbeetle) client for Node.js.
 
 ## Installation
 
@@ -9,6 +9,16 @@ Install the `tigerbeetle-node` module to your current working directory:
 npm install tigerbeetle-node
 ```
 
+If you run into issues, check out the distribution-specific install
+steps that are run in CI to test support:
+
+* [Alpine](./scripts/test_install_on_alpine.sh)
+* [Amazon Linux](./scripts/test_install_on_amazonlinux.sh)
+* [Debian](./scripts/test_install_on_debian.sh)
+* [Fedora](./scripts/test_install_on_fedora.sh)
+* [Ubuntu](./scripts/test_install_on_ubuntu.sh)
+* [RHEL](./scripts/test_install_on_rhelubi.sh)
+
 ### Prerequisites
 
 * NodeJS >= `14.0.0`. _(If the correct version is not installed, an installation error will occur)_
@@ -24,140 +34,282 @@ For the moment, only one client can be instantiated globally per process.
 Future releases will allow multiple client instantiations.
 
 ```js
-import { createClient } from 'tigerbeetle-node'
+const {
+  createClient,
+  CreateAccountError,
+  CreateTransferError,
+  AccountFlags,
+  TransferFlags,
+} = require('tigerbeetle-node');
 
 const client = createClient({
   cluster_id: 0,
   replica_addresses: ['3001', '3002', '3003']
-})
+});
 ```
 
-One of the ways TigerBeetle achieves its performance is through batching. 
-This is reflected in the below function interfaces where each one takes in an array of events.
+One of the ways TigerBeetle achieves its performance is through
+batching. This is reflected in the below function interfaces where
+each one takes in an array of items.
+
+### Sidenote: `BigInt`
+
+TigerBeetle uses 64-bit integers for many fields while JavaScript's
+builtin `Number` maximum value is 2^53-1. The `n` suffix in JavaScript
+means the value is a BigInt. This is useful for literal numbers. If
+you already have a `Number` variable though, you can call the `BigInt`
+constructor to get a `BigInt` from it. For example, `1n` is the same
+as `BigInt(1)`.
+
+## Creating Accounts: `client.createAccounts`
 
-### Account Creation
+See details for account fields in the [Accounts
+reference](https://docs.tigerbeetle.com/reference/accounts).
 
 ```js
 const account = {
-    id: 137n, // u128
-    user_data: 0n, // u128, opaque third-party identifier to link this account to an external entity:
-    reserved: Buffer.alloc(48, 0), // [48]u8
-    ledger: 1,   // u32, ledger value
-    code: 718, // u16, a chart of accounts code describing the type of account (e.g. clearing, settlement)
-    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.
+  id: 137n, // u128
+  user_data: 0n, // u128, opaque third-party identifier to link this account to an external entity:
+  reserved: Buffer.alloc(48, 0), // [48]u8
+  ledger: 1,   // u32, ledger value
+  code: 718, // u16, a chart of accounts code describing the type of account (e.g. clearing, settlement)
+  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.
+};
+
+const errors = await client.createAccounts([account]);
+if (errors.length) {
+  // Grab a human-readable message from the response
+  console.log(CreateAccountError[errors[0].code]);
 }
+```
+
+### Account Flags
+
+The account `flags` value is a bitfield. See details for these flags in
+the [Accounts
+reference](https://docs.tigerbeetle.com/reference/accounts#flags).
 
-const errors = await client.createAccounts([account])
+To toggle behavior for an account, combine enum values stored in the
+`AccountFlags` object (in TypeScript it is an actual enum) with
+bitwise-or:
+
+* `AccountFlags.linked`
+* `AccountFlags.debits_must_not_exceed_credits`
+* `AccountFlags.credits_must_not_exceed_credits`
+
+For example, to link `account0` and `account1`, where `account0`
+additionally has the `debits_must_not_exceed_credits` constraint:
+
+```js
+const account0 = { ... account values ... };
+const account1 = { ... account values ... };
+account0.flags = AccountFlags.linked | AccountFlags.debits_must_not_exceed_credits;
+// Create the account
+const errors = client.createAccounts([account0, account1]);
 ```
-Successfully executed events return an empty array whilst unsuccessful ones return an array with errors for **only the ones that failed**. An error will point to the index in the submitted array of the failed event.
+
+### Response and Errors
+
+The response is an empty array if all accounts were created
+successfully. If the response is non-empty, each object in the
+response array contains error information for an account that
+failed. The error object contains an error code and the index of the
+account in the request batch.
+
 ```js
-  const errors = await client.createAccounts([account1, account2, account3])
+const errors = await client.createAccounts([account1, account2, account3]);
 
-  // errors = [{ index: 1, code: 1 }]
-  const error = errors[0]
+// errors = [{ index: 1, code: 1 }];
+for (const error of errors) {
   switch (error.code) {
-    case CreateAccountError.exists: {
-      console.error(`Batch event at ${error.index} already exists.`)
-    }
+    case CreateAccountError.exists:
+      console.error(`Batch account at ${error.index} already exists.`);
+	  break;
+    default:
+      console.error(`Batch account at ${error.index} failed to create: ${CreateAccountError[error.code]}.`);
   }
+}
 ```
-The example above shows that the event in index 1 failed with error 1. This means that `account1` and `account3` were created successfully but not `account2`.
 
-The `flags` on an account provide a way for you to enforce policies by toggling the bits below.
-| bit 0    | bit 1                            | bit 2                                   |
-|----------|----------------------------------|-----------------------------------------|
-| `linked` | `debits_must_not_exceed_credits` | `credits_must_not_exceed_debits` |
+The example above shows that the account in index 1 failed with
+error 1. This error here means that `account1` and `account3` were
+created successfully. But `account2` was not created.
 
-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),
-    debits_must_not_exceed_credits = (1 << 1),
-    credits_must_not_exceed_debits = (1 << 2)
-  }
+To handle errors you can either 1) exactly match error codes returned
+from `client.createAccounts` with enum values in the
+`CreateAccountError` object, or you can 2) look up the error code in
+the `CreateAccountError` object for a human-readable string.
 
-  let flags = 0
-  flags |= CreateAccountFlags.debits_must_not_exceed_credits
-```
+## Account Lookup: `client.lookupAccounts`
+
+Account lookup is batched, like account creation. Pass in all `id`s to
+fetch, and matched accounts are returned.
 
-### Account Lookup
+If no account matches an `id`, no object is returned for that
+account. So the order of accounts in the response is not necessarily
+the same as the order of `id`s in the request. You can refer to the
+`id` field in the response to distinguish accounts.
 
-The `id` of the account is used for lookups. Only matched accounts are returned.
 ```js
-  // account 137n exists, 138n does not
-  const accounts = await client.lookupAccounts([137n, 138n])
-
-  /**
-   * const accounts = [{
-   *   id: 137n,
-   *   user_data: 0n,
-   *   reserved: Buffer,
-   *   ledger: 1,
-   *   code: 718,
-   *   flags: 0,
-   *   debits_pending: 0n,
-   *   debits_posted: 0n,
-   *   credits_pending: 0n,
-   *   credits_posted: 0n,
-   *   timestamp: 1623062009212508993n,
-   * }]
-   */
-```
-
-### Creating a Transfer
+// account 137n exists, 138n does not
+const accounts = await client.lookupAccounts([137n, 138n]);
+/* console.log(accounts);
+ * [{
+ *   id: 137n,
+ *   user_data: 0n,
+ *   reserved: Buffer,
+ *   ledger: 1,
+ *   code: 718,
+ *   flags: 0,
+ *   debits_pending: 0n,
+ *   debits_posted: 0n,
+ *   credits_pending: 0n,
+ *   credits_posted: 0n,
+ *   timestamp: 1623062009212508993n,
+ * }]
+ */
+```
+
+## Creating Transfers: `client.createTransfers`
 
 This creates a journal entry between two accounts.
+
+See details for transfer fields in the [Transfers
+reference](https://docs.tigerbeetle.com/reference/transfers).
+
 ```js
 const transfer = {
-    id: 1n, // u128
-    // Double-entry accounting:
-    debit_account_id: 1n,  // u128
-    credit_account_id: 2n, // u128
-    // 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.
+  id: 1n, // u128
+  pending_id: 0n, // u128
+  // Double-entry accounting:
+  debit_account_id: 1n,  // u128
+  credit_account_id: 2n, // u128
+  // 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: 1,  // u32, ledger for transfer (e.g. currency).
+  // Chart of accounts code describing the reason for the transfer:
+  code: 720,  // 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]);
+for (const error of errors) {
+  switch (error.code) {
+    default:
+      console.error(`Batch transfer at ${error.index} failed to create: ${CreateAccountError[error.code]}.`);
+  }
 }
-const errors = await client.createTransfers([transfer])
 ```
-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.
 
-Transfers within a batch may also be linked (see [linked events](#linked-events)).
+### Response and Errors
+
+The response is an empty array if all transfers were created
+successfully. If the response is non-empty, each object in the
+response array contains error information for an transfer that
+failed. The error object contains an error code and the index of the
+transfer in the request batch.
+
 ```js
-  enum TransferFlags {
-    linked = (1 << 0),
-    pending = (1 << 1),
-    post_pending_transfer = (1 << 2),
-    void_pending_transfer = (1 << 3)
+const errors = await client.createTransfers([transfer1, transfer2, transfer3]);
+
+// errors = [{ index: 1, code: 1 }];
+for (const error of errors) {
+  switch (error.code) {
+    case CreateTransferError.exists:
+      console.error(`Batch transfer at ${error.index} already exists.`);
+	  break;
+    default:
+      console.error(`Batch transfer at ${error.index} failed to create: ${CreateTransferError[error.code]}.`);
   }
-  
-  // Two-phase transfer (pending):
-  let flags = 0n
-  flags |= TransferFlags.pending
+}
+```
+
+The example above shows that the transfer in index 1 failed with
+error 1. This error here means that `transfer1` and `transfer3` were
+created successfully. But `transfer2` was not created.
+
+To handle errors you can either 1) exactly match error codes returned
+from `client.createTransfers` with enum values in the
+`CreateTransferError` object, or you can 2) look up the error code in
+the `CreateTransferError` object for a human-readable string.
+
+### Batching
+
+TigerBeetle performance is maximized when you batch inserts. The
+client does not do this automatically for you. So, for example, you
+can insert 1 million transfers one at a time like so:
+
+```js
+for (let i = 0; i < 1_000_000; i++) {
+  const errors = client.createTransfers(transfers[i]);
+  // error handling omitted
+}
+```
+
+But the insert rate will be a fraction of potential. Instead, always
+batch what you can. The maximum batch size is set in the TigerBeetle
+server. The default is 8191.
+
+```js
+const BATCH_SIZE = 8191;
+for (let i = 0; i < 1_000_000; i += BATCH_SIZE) {
+  const errors = client.createTransfers(transfers.slice(i, Math.min(transfers.length, BATCH_SIZE)));
+  // error handling omitted
+}
+```
+
+### Transfer Flags
+
+The transfer `flags` value is a bitfield. See details for these flags in
+the [Transfers
+reference](https://docs.tigerbeetle.com/reference/transfers#flags).
 
-  // Linked two-phase transfer (pending):
-  let flags = 0n
-  flags |= TransferFlags.linked
-  flags |= TransferFlags.pending
+To toggle behavior for a transfer, combine enum values stored in the
+`TransferFlags` object (in TypeScript it is an actual enum) with
+bitwise-or:
+
+* `TransferFlags.linked`
+* `TransferFlags.pending`
+* `TransferFlags.post_pending_transfer`
+* `TransferFlags.void_pending_transfer`
+
+For example, to link `transfer0` and `transfer1`:
+
+```js
+const transfer0 = { ... transfer values ... };
+const transfer1 = { ... transfer values ... };
+transfer0.flags = TransferFlags.linked;
+// Create the transfer
+const errors = client.createTransfers([transfer0, transfer1]);
 ```
 
-### Post a Pending Transfer (2-Phase)
+#### Two-Phase Transfers
+
+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
+post pending transfer then needs to be sent to post or void the
+transfer.
+
+##### Post a Pending Transfer
+
+With `transfer.flags == TransferFlags.post_pending_transfer`,
+TigerBeetle will post the transfer. TigerBeetle will atomically roll
+back the changes to `debits_pending` and `credits_pending` of the
+appropriate accounts and apply them to the `debits_posted` and
+`credits_posted` balances.
 
-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 post = {
     id: 2n, // u128, must correspond to the transfer id
@@ -168,9 +320,58 @@ const post = {
 const errors = await client.createTransfers([post])
 ```
 
-### Linked Events
+## Transfer Lookup: `client.lookupTransfers`
+
+NOTE: While transfer lookup exists, it is not a flexible query API. We
+are developing query APIs and there will be new methods for querying
+transfers in the future.
+
+Transfer lookup is batched, like transfer creation. Pass in all `id`s to
+fetch, and matched transfers are returned.
+
+If no transfer matches an `id`, no object is returned for that
+transfer. So the order of transfers in the response is not necessarily
+the same as the order of `id`s in the request. You can refer to the
+`id` field in the response to distinguish transfers.
+
+```js
+// transfer 1n exists, 2n does not
+const transfers = await client.lookupTransfers([1n, 2n]);
+/* console.log(transfers);
+ * [{
+ *   id: 1n,
+ *   pending_id: 0n,
+ *   debit_account_id: 1n,
+ *   credit_account_id: 2n,
+ *   user_data: 0n,
+ *   reserved: 0n,
+ *   timeout: 0n,
+ *   ledger: 1,
+ *   code: 720,
+ *   flags: 0,
+ *   amount: 10n,
+ *   timestamp: 1623062009212508993n,
+ * }]
+ */
+```
+
+## Linked Events
+
+When the `linked` flag is specified for the `createAccount` or
+`createTransfer` 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.
 
-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`.
+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`.
 
 ```js
 let batch = []
@@ -218,7 +419,7 @@ const errors = await client.createTransfers(batch)
 To get up and running when cloning the repo:
 
 ```shell
-git clone --recurse-submodules https://github.com/coilhq/tigerbeetle-node.git
+git clone --recurse-submodules https://github.com/tigerbeetledb/tigerbeetle-node.git
 cd tigerbeetle-node/
 npm install --include dev # This will automatically install and build everything you need.
 ```
@@ -243,7 +444,8 @@ npm run benchmark
 #### Test
 
 ```shell
-./tigerbeetle init --cluster=1 --replica=0 --directory=.
-./tigerbeetle start --cluster=1 --replica=0 --directory=. --addresses=3001
+./tigerbeetle format --cluster=0 --replica=0 ./cluster_0_replica_0_test.tigerbeetle
+./tigerbeetle start --addresses=3001 ./cluster_0_replica_0_test.tigerbeetle > tigerbeetle_test.log 2>&1
 npm run test
 ```
+For more information, type; `./tigerbeetle -h` 

package/dist/index.d.ts

@@ -24,25 +24,23 @@ export declare enum AccountFlags {
 }
 export declare enum CreateAccountError {
     linked_event_failed = 1,
-    reserved_flag = 2,
-    reserved_field = 3,
-    id_must_not_be_zero = 4,
-    ledger_must_not_be_zero = 5,
-    code_must_not_be_zero = 6,
-    mutually_exclusive_flags = 7,
-    overflows_debits = 8,
-    overflows_credits = 9,
-    exceeds_credits = 10,
-    exceeds_debits = 11,
-    exists_with_different_flags = 12,
-    exists_with_different_user_data = 13,
-    exists_with_different_ledger = 14,
-    exists_with_different_code = 15,
-    exists_with_different_debits_pending = 16,
-    exists_with_different_debits_posted = 17,
-    exists_with_different_credits_pending = 18,
-    exists_with_different_credits_posted = 19,
-    exists = 20
+    linked_event_chain_open = 2,
+    reserved_flag = 3,
+    reserved_field = 4,
+    id_must_not_be_zero = 5,
+    id_must_not_be_int_max = 6,
+    ledger_must_not_be_zero = 7,
+    code_must_not_be_zero = 8,
+    debits_pending_must_be_zero = 9,
+    debits_posted_must_be_zero = 10,
+    credits_pending_must_be_zero = 11,
+    credits_posted_must_be_zero = 12,
+    mutually_exclusive_flags = 13,
+    exists_with_different_flags = 14,
+    exists_with_different_user_data = 15,
+    exists_with_different_ledger = 16,
+    exists_with_different_code = 17,
+    exists = 18
 }
 export declare type CreateAccountsError = {
     index: number;
@@ -70,54 +68,59 @@ export declare enum TransferFlags {
 }
 export declare enum CreateTransferError {
     linked_event_failed = 1,
-    reserved_flag = 2,
-    reserved_field = 3,
-    id_must_not_be_zero = 4,
-    debit_account_id_must_not_be_zero = 5,
-    credit_account_id_must_not_be_zero = 6,
-    accounts_must_be_different = 7,
-    pending_id_must_be_zero = 8,
-    pending_transfer_must_timeout = 9,
-    ledger_must_not_be_zero = 10,
-    code_must_not_be_zero = 11,
-    amount_must_not_be_zero = 12,
-    debit_account_not_found = 13,
-    credit_account_not_found = 14,
-    accounts_must_have_the_same_ledger = 15,
-    transfer_must_have_the_same_ledger_as_accounts = 16,
-    exists_with_different_flags = 17,
-    exists_with_different_debit_account_id = 18,
-    exists_with_different_credit_account_id = 19,
-    exists_with_different_user_data = 20,
-    exists_with_different_pending_id = 21,
-    exists_with_different_timeout = 22,
-    exists_with_different_code = 23,
-    exists_with_different_amount = 24,
-    exists = 25,
-    overflows_debits_pending = 26,
-    overflows_credits_pending = 27,
-    overflows_debits_posted = 28,
-    overflows_credits_posted = 29,
-    overflows_debits = 30,
-    overflows_credits = 31,
-    exceeds_credits = 32,
-    exceeds_debits = 33,
-    cannot_post_and_void_pending_transfer = 34,
-    pending_transfer_cannot_post_or_void_another = 35,
-    timeout_reserved_for_pending_transfer = 36,
-    pending_id_must_not_be_zero = 37,
-    pending_id_must_be_different = 38,
-    pending_transfer_not_found = 39,
-    pending_transfer_not_pending = 40,
-    pending_transfer_has_different_debit_account_id = 41,
-    pending_transfer_has_different_credit_account_id = 42,
-    pending_transfer_has_different_ledger = 43,
-    pending_transfer_has_different_code = 44,
-    exceeds_pending_transfer_amount = 45,
-    pending_transfer_has_different_amount = 46,
-    pending_transfer_already_posted = 47,
-    pending_transfer_already_voided = 48,
-    pending_transfer_expired = 49
+    linked_event_chain_open = 2,
+    reserved_flag = 3,
+    reserved_field = 4,
+    id_must_not_be_zero = 5,
+    id_must_not_be_int_max = 6,
+    debit_account_id_must_not_be_zero = 7,
+    debit_account_id_must_not_be_int_max = 8,
+    credit_account_id_must_not_be_zero = 9,
+    credit_account_id_must_not_be_int_max = 10,
+    accounts_must_be_different = 11,
+    pending_id_must_be_zero = 12,
+    pending_transfer_must_timeout = 13,
+    ledger_must_not_be_zero = 14,
+    code_must_not_be_zero = 15,
+    amount_must_not_be_zero = 16,
+    debit_account_not_found = 17,
+    credit_account_not_found = 18,
+    accounts_must_have_the_same_ledger = 19,
+    transfer_must_have_the_same_ledger_as_accounts = 20,
+    exists_with_different_flags = 21,
+    exists_with_different_debit_account_id = 22,
+    exists_with_different_credit_account_id = 23,
+    exists_with_different_user_data = 24,
+    exists_with_different_pending_id = 25,
+    exists_with_different_timeout = 26,
+    exists_with_different_code = 27,
+    exists_with_different_amount = 28,
+    exists = 29,
+    overflows_debits_pending = 30,
+    overflows_credits_pending = 31,
+    overflows_debits_posted = 32,
+    overflows_credits_posted = 33,
+    overflows_debits = 34,
+    overflows_credits = 35,
+    exceeds_credits = 36,
+    exceeds_debits = 37,
+    cannot_post_and_void_pending_transfer = 38,
+    pending_transfer_cannot_post_or_void_another = 39,
+    timeout_reserved_for_pending_transfer = 40,
+    pending_id_must_not_be_zero = 41,
+    pending_id_must_not_be_int_max = 42,
+    pending_id_must_be_different = 43,
+    pending_transfer_not_found = 44,
+    pending_transfer_not_pending = 45,
+    pending_transfer_has_different_debit_account_id = 46,
+    pending_transfer_has_different_credit_account_id = 47,
+    pending_transfer_has_different_ledger = 48,
+    pending_transfer_has_different_code = 49,
+    exceeds_pending_transfer_amount = 50,
+    pending_transfer_has_different_amount = 51,
+    pending_transfer_already_posted = 52,
+    pending_transfer_already_voided = 53,
+    pending_transfer_expired = 54
 }
 export declare type CreateTransfersError = {
     index: number;