Merge e0057d6 into 1cf1ffa

package.json

@@ -18,7 +18,7 @@
         "rpc": "node test/bin/startRPC",
         "lint": "eslint ./ --cache",
         "lint-all": "eslint ./",
-        "prerelease-alpha": "npm run build && npm version prerelease",
+        "prepublish-alpha": "npm run build && npm version prerelease",
         "publish-alpha": "npm publish --access-public --tag alpha",
         "publish": "npm dist-tag add @vite/vitejs@alpha latest"
     },

src/Wallet/account.ts

@@ -292,11 +292,11 @@ class Account {
     }
 
     async callContract({
-        toAddress, abi, methodName, params, tokenId, amount
+        toAddress, jsonInterface, params, tokenId, amount
     }) {
         const _callContractBlock = await this._client.buildinTxBlock.callContract({
             accountAddress: this.address, 
-            toAddress, abi, methodName, params, tokenId, amount
+            toAddress, jsonInterface, params, tokenId, amount
         });
         return this._client.buildinLedger.sendRawTx(_callContractBlock, this.privateKey);
     }

src/client/txBlock.ts

@@ -5,6 +5,7 @@ import { RPCresponse, SBPregBlock, block8, block7, revokeVotingBlock, quotaBlock
 import { checkParams, validNodeName } from "utils/tools";
 import { formatAccountBlock, validReqAccountBlock } from "utils/builtin";
 import { getAccountBlock as _getAccountBlock, getSendTxBlock, getReceiveTxBlock } from 'utils/accountBlock';
+import {encodeFunctionCall} from "utils/abi"
 
 import client from '.';
 
@@ -339,19 +340,19 @@ export default class tx {
     }
 
     async callContract({
-        accountAddress, toAddress, tokenId, amount, abi, methodName, params, height, prevHash, snapshotHash
+        accountAddress, toAddress, tokenId, amount, jsonInterface, params=[], height, prevHash, snapshotHash
     }: callContractBlock, requestType = 'async') {
-        let err = checkParams({ toAddress, abi, methodName, tokenId, amount }, ['toAddress', 'abi', 'methodName', 'tokenId', 'amount']);
+        let err = checkParams({ toAddress, jsonInterface, tokenId, amount }, ['toAddress', 'jsonInterface','tokenId', 'amount']);
         if (err) {
             return Promise.reject(err);
         }
 
-        const result:RPCresponse = await this._client.contract.getCallContractData(abi, methodName, params);
+        // const result:RPCresponse = await this._client.contract.getCallContractData(abi, methodName, params);
         return this[`${requestType}AccountBlock`]({
             blockType: 2,
             accountAddress,
             toAddress,
-            data: result,
+            data: encodeFunctionCall(jsonInterface,params),
             height, prevHash, snapshotHash, tokenId, amount
         });
     }

src/const/contract.ts

@@ -4,3 +4,5 @@ export const Default_Hash = '000000000000000000000000000000000000000000000000000
 export const Quota_Addr = 'vite_000000000000000000000000000000000000000309508ba646';
 export const Vote_Addr = 'vite_000000000000000000000000000000000000000270a48cc491';
 export const Register_Addr = 'vite_0000000000000000000000000000000000000001c9e9f25417';
+export const DexFund_Addr='vite_000000000000000000000000000000000000000617d47459a8';
+export const DexTrade_Addr='vite_000000000000000000000000000000000000000768ef0e6238';

src/const/type.ts

@@ -230,11 +230,10 @@ export declare type createContractBlock = {
 export declare type callContractBlock = {
     accountAddress: Address, 
     toAddress: Address,
-    abi: string, 
+    jsonInterface: object, 
     tokenId: TokenId,
     amount: BigInt,
-    methodName: string,
-    params?: string,
+    params?: [],
     prevHash?: Hex,
     height?: Uint64,
     snapshotHash?: Hex

src/utils/abi/index.ts

@@ -1,35 +1,33 @@
-import { isArray  } from 'utils/encoder';
+import { isArray } from 'utils/encoder';
 import encodeFunction from './encodeFunction';
-import { encodeParameter, encodeParameters, decodeParameter, decodeParameters } from './coder/index';
+import { encodeParameter as _encodeParameter, encodeParameters as _encodeParameters, decodeParameter as _decodeParameter, decodeParameters as _decodeParameters } from './coder';
 
-export default {
-    encodeFunctionSignature,
-    encodeLogSignature(jsonFunction, mehtodName?) {
-        return encodeFunction(jsonFunction, mehtodName);
-    },
-    encodeParameter(type, param) {
-        return encodeParameter(type, param).result;
-    },
-    encodeParameters,
-    encodeFunctionCall(jsonInterface, params) {
-        let inputs = jsonInterface.inputs;
-        let types = [];
-        inputs.forEach(({ type }) => {
-            types.push(type);
-        });
-        return encodeFunctionSignature(jsonInterface) + encodeParameters(types, params)
-    },
-    decodeParameter,
-    decodeParameters,
-    decodeLog
+
+export function encodeLogSignature(jsonFunction, mehtodName?) {
+    return encodeFunction(jsonFunction, mehtodName);
+}
+export function encodeParameter(type, param) {
+    return _encodeParameter(type, param).result;
+}
+export const encodeParameters = _encodeParameters
+export const decodeParameter = _decodeParameter
+export const decodeParameters = _decodeParameters
+export function encodeFunctionCall(jsonInterface, params) {
+    let inputs = jsonInterface.inputs;
+    let types = [];
+    inputs.forEach(({ type }) => {
+        types.push(type);
+    });
+    return encodeFunctionSignature(jsonInterface) + encodeParameters(types, params)
 }
 
-function encodeFunctionSignature(jsonFunction, mehtodName?) {
+
+export function encodeFunctionSignature(jsonFunction, mehtodName?) {
     let result = encodeFunction(jsonFunction, mehtodName);
     return result.slice(0, 8);
 }
 
-function decodeLog(inputs, data = '', topics) {
+export function decodeLog(inputs, data = '', topics) {
     let topicCount = 0;
     topics = isArray(topics) ? topics : [topics];
 
@@ -52,7 +50,7 @@ function decodeLog(inputs, data = '', topics) {
 
     let returnValues = {};
     let notIndexedCount = 0;
-    
+
     indexedParams.forEach(({ indexed, name, result }, i) => {
         if (!indexed) {
             result = notIndexedParams[notIndexedCount];

test/utils/abi.js

@@ -1,6 +1,6 @@
 const assert = require('assert');
 
-import abi from 'utils/abi/index';
+import * as abi from 'utils/abi/index';
 
 describe('utils/tools', function () {
     it('encodeParameter', function () {