Example Remote Nonce Cache Provider

const { NonceType } = require('avn-api');
const Redis = require('ioredis');
const Redlock = require('redlock');

class TestRedisNonceCacheProvider {
  SLOT_PREFIX = '{avnApi}:';
  constructor() {
    this.nonceMap = {};
    this.redisClient;
  }

  async connect() {
    this.redisClient = new Redis();

    this.lockTtlMs = 5000;
    this.redlock = new Redlock([this.redisClient], {
      driftFactor: 0.01,
      retryCount: 10,
      retryDelay: 500,
      retryJitter: 200
    });

    console.info(
      'Connected to Redis database:\n',
      (await this.redisClient.hello()).map((e, i) => (i % 2 == 0 ? e + ':' : e + ', ')).join('')
    );

    return this;
  }

  async initUserNonceCache(signerAddress) {
    const signerKey = this.getSignerKey(signerAddress);
    const isUserSetup = await this.redisClient.get(signerKey);
    if (isUserSetup !== 'true' && isUserSetup !== true) {
      // Set the signer
      await this.redisClient.set(this.getSignerKey(signerAddress), true);
    }
  }

  async getNonceData(signerAddress, nonceId) {
    const nonceData = await this.readNonceDatafromRedis(signerAddress, nonceId);
    return nonceData;
  }

  async getNonceAndLock(signerAddress, nonceId) {
    const lock = await this.redlock.acquire([`redlock-${signerAddress}${nonceId}`], this.lockTtlMs);
    try {
      let nonceData = await this.readNonceDatafromRedis(signerAddress, nonceId);
      if (nonceData.locked === true) {
        return { lockAquired: false, data: nonceData };
      }

      const lockId = this.getLockId(signerAddress, nonceId, nonceData.nonce);
      nonceData.locked = true;
      nonceData.lockId = lockId;

      await this.saveNonceDataToRedis(signerAddress, nonceId, nonceData);
      return { lockAquired: true, data: nonceData };
    } finally {
      await lock.unlock();
    }
  }

  async incrementNonce(lockId, signerAddress, nonceId, updateLastUpdate) {
    let nonceData = await this.readNonceDatafromRedis(signerAddress, nonceId);
    if (nonceData.locked !== true || nonceData.lockId !== lockId) {
      throw new Error(
        `Invalid attempt to increment nonce. Current lock: ${nonceData.lockId} LockId: ${lockId}, signerAddress: ${signerAddress}, nonceId: ${nonceId}`
      );
    }

    nonceData.nonce = parseInt(nonceData.nonce) + 1;
    if (updateLastUpdate === true) {
      nonceData.lastUpdated = Date.now();
    }

    await this.saveNonceDataToRedis(signerAddress, nonceId, nonceData);
    return nonceData;
  }

  async unlockNonce(lockId, signerAddress, nonceId) {
    let nonceData = await this.readNonceDatafromRedis(signerAddress, nonceId);
    if (nonceData.locked !== true || nonceData.lockId !== lockId) {
      throw new Error(
        `Invalid attempt to unlock nonce. Current lock: ${nonceData.lockId}. LockId: ${lockId}, signerAddress: ${signerAddress}, nonceId: ${nonceId}`
      );
    }
    nonceData.locked = false;
    nonceData.lockId = undefined;
    await this.saveNonceDataToRedis(signerAddress, nonceId, nonceData);
  }

  async setNonce(lockId, signerAddress, nonceId, nonce) {
    let nonceData = await this.readNonceDatafromRedis(signerAddress, nonceId);
    if (nonceData.locked !== true || nonceData.lockId !== lockId) {
      throw new Error(
        `Invalid attempt to set nonce. Current lock: ${nonceData.lockId}. LockId: ${lockId}, signerAddress: ${signerAddress}, nonceId: ${nonceId}`
      );
    }

    nonceData = { nonce: nonce, lastUpdated: Date.now() };
    await this.saveNonceDataToRedis(signerAddress, nonceId, nonceData);
  }

  getLockId(signerAddress, nonceId, nonce) {
    return `${Date.now()}-${nonce}-${signerAddress}-${nonceId}`;
  }

  getNonceKey(signerAddress, nonceId) {
    return `${this.getSignerKey(signerAddress)}-${nonceId}`;
  }

  getSignerKey(signerAddress) {
    return `${this.SLOT_PREFIX}-${signerAddress}`;
  }

  async readNonceDatafromRedis(signerAddress, nonceId) {
    const nonceKey = this.getNonceKey(signerAddress, nonceId);
    const nonceData = await this.redisClient.hgetall(nonceKey);
    // deal with boolean values
    nonceData.locked = nonceData.locked === 'true';
    return nonceData;
  }

  async saveNonceDataToRedis(signerAddress, nonceId, nonceData) {
    const nonceKey = this.getNonceKey(signerAddress, nonceId);
    await this.redisClient.hset(nonceKey, nonceData);
  }
}

module.exports = TestRedisNonceCacheProvider;