x-wallet v0.1.0

Wallet Monitor

This is a npm package that allows you to monitor the balance of multiple wallets in multiple blockchains. Along monitoring, it can also export the balances as prometheus metrics and perform rebalancing strategies between your wallets.
It can be used as a package within a nodejs application (library modality) or as a gRPC service (service modality).

Table of Contents

• TL;DR
• Contributions
• WalletManager
• ChainWalletManager
• WalletToolbox
• Supported Tokens
• gRPC service

TL;DR

WalletManager exposes a few utilities to monitor the balance of a wallet in a blockchain. Optionally, you can also monitor the balance of tokens for the wallet.
The module requires near zero configuration by defaulting most required values to what would be reasonable, but it can be configured more granularly if needed.
WalletManager uses underneath multiple ChainWalletManager objects, one for each blockchain you want to monitor.
ChainWalletManager in turn uses a WalletToolbox object to perform the actual monitoring of the wallet.
These objects are composed rather than inherited and this means that they will have, in general, different interfaces, but it is always possible to use them independently.
Check out the example.

Contributions

Any feature request for this project is welcomed and will be considered for implementation.
The more detail you can provide about your use case, the better.

WalletManager

This is the main object of the package. It is responsible for efficiently dispatching your configuration to the right ChainWalletManager objects and for aggregating the results. It can do locking of each wallet and will also take care of exporting balances, metrics and errors if you want it to.
In general, it is a useful class to treat a collection of ChainWalletManager objects as a single object.

It's useful to explain the properties and features of this class by looking at the configuration and options that are passed to the constructor (using zod).

WalletManagerConfig

export const WalletManagerChainConfigSchema = z.object({
  network: z.string().optional(),
  chainConfig: z.any().optional(),
  rebalance: z.object({
    enabled: z.boolean(),
    strategy: z.string().optional(),
    interval: z.number().optional(),
    minBalanceThreshold: z.number().optional(),
    maxGasPrice: z.number().optional(),
    gasLimit: z.number().optional(),
  }).optional(),
  wallets: z.array(WalletConfigSchema),
})

export const WalletManagerConfigSchema = z.record(z.string(), WalletManagerChainConfigSchema)

In short, each record keys is the name of a chain. The value within that record is a network name, an optional rebalancing strategy and a collection of wallets.
Also, check out the rebalancing example.

WalletManagerOptions

export const WalletManagerOptionsSchema = z.object({
  logger: z.any().optional(),
  logLevel: z.union([
      z.literal('error'),
      z.literal('warn'),
      z.literal('info'),
      z.literal('debug'),
      z.literal('verbose'),
      z.literal('silent'),
  ]).optional(),
  balancePollInterval: z.number().optional(),
  metrics: z.object({
    enabled: z.boolean(),
    port: z.number().optional(),
    path: z.string().optional(),
    registry: z.any().optional(),
    serve: z.boolean().optional(),
  }).optional(),
});

The options applied to all blockchains and wallets monitored specify logging and if/where to expose prometheus metrics.

There are cases where WalletManager needs to be used with all its functionality but the application code does not need to interact with the monitoring or rebalancing. In such cases, you can use buildWalletManager convenience function which will return a WalletManager masked by the correct interface that will only allow you to interact with the locking mechanisms of the wallets.

ChainWalletManager

This class knows how to use a WalletToolbox to perform chain-specific monitoring and transactional operations.
The interface is mostly similar to WalletManager but it is pending to be refactored to be more consistent.

WalletToolbox

A WalletToolbox handles the communication with the blockchain and is responsible for knowing reasonable defaults for the blockchain endpoints, networks, token IDs, which sdk to use and how to handle sdk results.

This object is also really useful on its own if you want to have fine-grained control over which network calls you are making.

Supported Tokens

While you can pass any token address to the wallet monitor, for simplicity a list of supported tokens is provided so you can use their symbols instead. See the table below:

Ethereum

Binance Smart Chain

Polygon

Avalanche

Fantom

Celo

Moonbeam

Arbitrum

SUI