openchain-nodejs-ts-yxl 1.0.1

package/index.d.ts

@@ -0,0 +1,186 @@
+declare class OpenChainSDK {
+  constructor(config: { host: string });
+
+  account: {
+    create(): Promise<{ errorCode: number; result: { privateKey: string; publicKey: string; address: string } }>;
+    getInfo(address: string): Promise<{ errorCode: number; result: AccountInfoResult }>;
+    checkValid(address: string): Promise<{ errorCode: number; result: { isValid: boolean } }>;
+    getBalance(address: string): Promise<{ errorCode: number; result: { balance: string } }>;
+    getNonce(address: string): Promise<{ errorCode: number; result: { nonce: string } }>;
+    getMetadata(params: { address: string; key: string }): Promise<{ errorCode: number; result: MetadataResult }>;
+    isActivated(address: string): Promise<{ errorCode: number; result: { isActivated: boolean } }>;
+  };
+
+  contract: {
+    getInfo(contractAddress: string): Promise<{ errorCode: number; result: ContractInfoResult }>;
+    getAddress(hash: string): Promise<{ errorCode: number; result: ContractAddressInfo[] }>;
+  };
+
+  block: {
+    getNumber(): Promise<{ errorCode: number; result: BlockNumberResult }>;
+    checkStatus(): Promise<{ errorCode: number; result: BlockStatusResult }>;
+    getTransactions(blockNumber: string): Promise<{ errorCode: number; result: TransactionListResult }>;
+  };
+
+  operation: {
+    assetIssueOperation(params: AssetIssueParams): { errorCode: number; result: OperationResult };
+    accountActivateOperation(params: AccountActivateParams): { errorCode: number; result: OperationResult };
+    accountSetMetadataOperation(params: MetadataParams): { errorCode: number; result: OperationResult };
+  };
+
+  transaction: {
+    buildBlob(params: TransactionParams): Promise<{ errorCode: number; result: TransactionBuildBlobResult }>;
+    sign(params: TransactionSignParams): Promise<{ errorCode: number; result: TransactionSignResult }>;
+    submit(params: TransactionSubmitParams): Promise<{ errorCode: number; result: TransactionSubmitResult }>;
+    getInfo(hash: string): Promise<{ errorCode: number; result: TransactionResult }>;
+  };
+}
+
+interface AccountInfoResult {
+  address: string;
+  balance: string;
+  nonce: string;
+  type_thresholds: Array<{
+    type: string;
+    threshold: string;
+  }>;
+}
+
+interface BlockNumberResult {
+  header: {
+    blockNumber: string;
+    timestamp: string;
+    txCount: number;
+  };
+}
+
+interface BlockStatusResult {
+  isSynchronous: boolean;
+  ledgerVersion: string;
+}
+
+interface TransactionListResult {
+  total_count: number;
+  transactions: Array<{
+    hash: string;
+    sourceAddress: string;
+    feeLimit: string;
+    gasPrice: string;
+  }>;
+}
+
+interface ContractCreateParams {
+  sourceAddress: string;
+  initBalance: string;
+  type: number;
+  payload: string;
+  initInput?: string;
+  metadata?: string;
+}
+
+interface OperationResult {
+  operation: {
+    type: string;
+    data: Record<string, any>;
+  };
+}
+
+interface ContractInfoResult {
+  contract: {
+    type: number;
+    payload: string;
+  };
+}
+
+interface ContractAddressInfo {
+  contract_address: string;
+  operation_index: number;
+}
+
+interface AssetIssueParams {
+  sourceAddress: string;
+  code: string;
+  assetAmount: string;
+  metadata?: string;
+}
+
+interface MetadataResult {
+  version: string;
+  value: string;
+}
+
+interface MetadataParams {
+  key: string;
+  value: string;
+  version?: string;
+  deleteFlag?: number;
+}
+
+interface AccountActivateParams {
+  sourceAddress: string;
+  destAddress: string;
+  initBalance: string;
+  metadata?: string;
+}
+
+interface TransactionParams {
+  sourceAddress: string;
+  nonce: string;
+  operations: OperationResult[];
+  gasPrice?: string;
+  feeLimit?: string;
+  metadata?: string;
+}
+
+interface TransactionBuildBlobResult {
+  transactionBlob: string;
+  hash: string;
+}
+
+interface TransactionSignParams {
+  transactionBlob: string;
+  privateKeys: string[];
+}
+
+interface TransactionSignResult {
+  signatures: Array<{
+    signData: string;
+    publicKey: string;
+  }>;
+}
+
+interface TransactionSubmitParams {
+  transactionBlob: string;
+  signatures: Array<{
+    signData: string;
+    publicKey: string;
+  }>;
+}
+
+interface TransactionSubmitResult {
+  hash: string;
+}
+
+interface TransactionResult {
+  totalCount: number;
+  transactions: Array<{
+    closeTime: string;
+    errorCode: number;
+    errorDesc: string;
+    hash: string;
+    ledgerSeq: string;
+    signatures: Array<{
+      signData: string;
+      publicKey: string;
+    }>;
+    transaction: {
+      sourceAddress: string;
+      nonce: string;
+      gasPrice: string;
+      feeLimit: string;
+      metadata?: string;
+      operations: OperationResult[];
+    };
+    txSize: number;
+  }>;
+}

package/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const OpenChainSDK = require('./lib/sdk');
+
+if (typeof window !== 'undefined' && typeof window.OpenChainSDK === 'undefined') {
+  window.OpenChainSDK = OpenChainSDK;
+}
+
+module.exports = OpenChainSDK;

package/lib/account/index.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const wrap = require('co-wrap-all');
+const is = require('is-type-of');
+const merge = require('merge-descriptors');
+const long = require('long');
+const JSONbig = require('json-bigint');
+const { keypair } = require('yxchain-encryption-nodejs');
+const errors = require('../exception');
+
+module.exports = Account;
+
+function Account(options) {
+  if (!(this instanceof Account)) {
+    return new Account(options);
+  }
+
+  this.options = options;
+}
+
+const proto = Account.prototype;
+
+merge(proto, require('../common/util'));
+
+/**
+ * Create account
+ * @return {Object}
+ */
+proto.create = function* () {
+  const kp = keypair.getKeyPair();
+  const privateKey = kp.encPrivateKey;
+  const publicKey = kp.encPublicKey;
+  const address = kp.address;
+
+  return this._responseData({
+    privateKey,
+    publicKey,
+    address,
+  });
+};
+
+/**
+ * Check address
+ * @param {String} address
+ * @return {Boolean}
+ */
+proto.checkValid = function* (address) {
+  const isValid = keypair.checkAddress(address);
+  return this._responseData({
+    isValid,
+  });
+};
+
+/**
+ * Get account information
+ * @param  {String} address
+ * @return {Object}
+ */
+proto.getInfo = function* (address) {
+  if (!keypair.checkAddress(address)) {
+    return this._responseError(errors.INVALID_ADDRESS_ERROR);
+  }
+
+  const res = yield this._request('get', 'getAccount', { address });
+  if (res.error_code !== 0) {
+    return this._responseError(errors.ACCOUNT_NOT_EXIST);
+  }
+
+  let nonce =  res.result.nonce;
+
+  nonce = nonce ? nonce : '0';
+  return this._responseData({
+    address: res.result.address,
+    balance: res.result.balance,
+    nonce: nonce,
+    assets: res.result.assets || [],
+    priv: res.result.priv || {},
+  });
+};
+
+/**
+ * Get account balance
+ * @param  {String} address
+ * @return {Object}
+ */
+proto.getBalance = function* (address) {
+  if (!keypair.checkAddress(address)) {
+    return this._responseError(errors.INVALID_ADDRESS_ERROR);
+  }
+
+  let info = yield this.getInfo(address);
+
+  if (info.errorCode === 0) {
+    return this._responseData({
+      balance: info.result.balance,
+    });
+  }
+
+  return this._responseError(errors.ACCOUNT_NOT_EXIST);
+};
+
+/**
+ * Get nonce
+ * @param  {String} address
+ * @return {Object}
+ */
+proto.getNonce = function* (address) {
+  if (!keypair.checkAddress(address)) {
+    return this._responseError(errors.INVALID_ADDRESS_ERROR);
+  }
+
+  let info = yield this.getInfo(address);
+
+  if (info.errorCode === 0) {
+    return this._responseData({
+      nonce: info.result.nonce,
+    });
+  }
+
+  return this._responseError(errors.ACCOUNT_NOT_EXIST);
+};
+
+proto.getAssets = function* (address) {
+  if (!keypair.checkAddress(address)) {
+    return this._responseError(errors.INVALID_ADDRESS_ERROR);
+  }
+
+  let info = yield this.getInfo(address);
+  if (info.errorCode === 0) {
+    return this._responseData({
+      assets: info.result.assets,
+    });
+  }
+
+  return this._responseError(errors.ACCOUNT_NOT_EXIST);
+};
+
+/**
+ * Get account metadata
+ * @param args
+ * @return {Object}
+ */
+proto.getMetadata = function* (args) {
+
+  if (is.array(args) || !is.object(args)) {
+    return this._responseError(errors.INVALID_ARGUMENTS);
+  }
+
+  const schema = {
+    address: {
+      required: true,
+      address: true,
+    },
+    key: {
+      required: true,
+      string: true,
+    },
+  };
+
+  if (!this._validate(args, schema).tag) {
+    const msg = this._validate(args, schema).msg;
+    return this._responseError(errors[msg]);
+  }
+
+  const address = args.address;
+  const key = args.key;
+
+  const info = yield this._request('get', 'getAccount', {
+    address,
+    key,
+  });
+
+  if (info.error_code !== 0) {
+    return this._responseError(errors.ACCOUNT_NOT_EXIST);
+  }
+
+  const data = info.result;
+  const metadata = {};
+  const metadatas = data.metadatas;
+
+  if (metadatas && is.array(metadatas) && metadatas.length > 0) {
+    metadatas.some(item => {
+      if (item.key === key) {
+        metadata.key = item.key;
+        metadata.value = item.value;
+        metadata.version = item.version;
+        return true;
+      }
+    });
+  }
+
+  return this._responseData({
+    metadata,
+  });
+};
+
+proto.isActivated = function* (address) {
+
+  if (is.undefined(address)) {
+    return this._responseError(errors.INVALID_ARGUMENTS);
+  }
+
+  const schema = {
+    address: {
+      required: true,
+      address: true,
+    },
+  };
+
+  const arg = {
+    address
+  };
+
+  if (!this._validate(arg, schema).tag) {
+    const msg = this._validate(arg, schema).msg;
+    return this._responseError(errors[msg]);
+  }
+
+  const info = yield this._request('get', 'getAccount', {
+    address,
+  });
+
+  let isActivated = false;
+
+  if (info.error_code === 0) {
+    isActivated = true;
+  }
+
+  return this._responseData({
+    isActivated,
+  });
+};
+
+wrap(proto);