openchain-sdk-yxl-ts/lib/account/index.js

OpenChain SDK for browser

import { keypair } from 'openchain-encryption-nodejs-yxl-ts';
// import errors from '../exception/index.js';
import CommonUtil from '../common/util.js';

class Account extends CommonUtil {
  constructor(options = {}) {
    super(options);
    
    if (!(this instanceof Account)) {
      return new Account(options);
    }
  }

  async create() {
    try {
      const kp = keypair.getKeyPair();
      return this._responseData({
        privateKey: kp.encPrivateKey,
        publicKey: kp.encPublicKey,
        address: kp.address,
      });
    } catch (err) {
      console.error('Error in create:', err);
      return this._responseError(this.options.errors.ACCOUNT_CREATE_ERROR);
    }
  }

  async checkValid(address) {
    try {
      const isValid = keypair.checkAddress(address);
      return this._responseData({ isValid });
    } catch (err) {
      console.error('Error in checkValid:', err);
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }
  }

  async getInfo(address) {
    if (!keypair.checkAddress(address)) {
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }

    try {
      const res = await this._request('get', 'getAccount', { address });
      if (res.error_code !== 0) {
        return this._responseError(this.options.errors.ACCOUNT_NOT_EXIST);
      }

      return this._responseData({
        ...res.result,
        nonce: res.result.nonce || 0,
      });
    } catch (err) {
      console.error('Error in getInfo:', err);
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }
  }

  async getBalance(address) {
    if (!keypair.checkAddress(address)) {
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }

    try {
      const info = await this.getInfo(address);
      console.log('getBalance', info);
      
      if (info.errorCode === 0) {
        return this._responseData({
          balance: info.result.balance,
        });
      }

      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    } catch (err) {
      console.error('Error in getBalance:', err);
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }
  }

  async getNonce(address) {
    if (!keypair.checkAddress(address)) {
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }

    try {
      const info = await this.getInfo(address);
      console.log('getNonce', info);
      
      if (info.errorCode === 0) {
        return this._responseData({
          nonce: info.result.nonce,
        });
      }

      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    } catch (err) {
      console.error('Error in getNonce:', err);
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }
  }

  async getAssets(address) {
    if (!keypair.checkAddress(address)) {
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }

    try {
      const info = await this.getInfo(address);
      if (info.errorCode === 0) {
        return this._responseData({
          assets: info.result.assets,
        });
      }

      return this._responseError(this.options.errors.ACCOUNT_NOT_EXIST);
    } catch (err) {
      console.error('Error in getAssets:', err);
      return this._responseError(this.options.errors.ACCOUNT_NOT_EXIST);
    }
  }

  async getMetadata(args) {
    if (Array.isArray(args) || typeof args !== 'object' || args === null) {
      return this._responseError(this.options.errors.INVALID_ARGUMENTS);
    }

    const schema = {
      address: {
        required: true,
        address: true,
      },
      key: {
        required: true,
        string: true,
      },
    };

    if (!this._validate(args, schema).tag) {
      return this._responseError(this.options.errors.INVALID_ARGUMENTS);
    }

    try {
      const info = await this._request('get', 'getAccount', {
        address: args.address,
        key: args.key
      });

      if (info.error_code !== 0) {
        return this._responseError(this.options.errors.ACCOUNT_NOT_EXIST);
      }

      const { metadatas } = info.result;
      const metadata = {};

      if (metadatas?.length > 0) {
        const found = metadatas.find(item => item.key === args.key);
        if (found) {
          metadata.key = found.key;
          metadata.value = found.value;
          metadata.version = found.version;
        }
      }

      return this._responseData({ metadata });
    } catch (err) {
      console.error('Error in getMetadata:', err);
      return this._responseError(this.options.errors.ACCOUNT_NOT_EXIST);
    }
  }

  async isActivated(address) {
    if (address === undefined) {
      return this._responseError(this.options.errors.INVALID_ARGUMENTS);
    }

    if (!keypair.checkAddress(address)) {
      return this._responseError(this.options.errors.INVALID_ADDRESS_ERROR);
    }

    const schema = {
      address: {
        required: true,
        address: true,
      },
    };

    if (!this._validate({ address }, schema).tag) {
      return this._responseError(this.options.errors.INVALID_ARGUMENTS);
    }

    try {
      const info = await this._request('get', 'getAccount', { address });
      return this._responseData({
        isActivated: info.error_code === 0
      });
    } catch (err) {
      console.error('Error in isActivated:', err);
      return this._responseError(this.options.errors.ACCOUNT_NOT_EXIST);
    }
  }
}

export default Account;