echpochmak/src/BaseContractObject/BaseContractObject.ts at master · wintexpro/echpochmak · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
/* eslint-disable @typescript-eslint/no-explicit-any */
import { readFileSync } from 'fs';
import { resolve } from 'path';
import { deploy } from '../Deploy/Deploy';

export abstract class BaseContract {
  public contractPackage: any;
  public contractPath: string;
  public isDeployed = false;
  public address: any;
  protected client: any;
  protected keys: any;

  constructor(
    contractPath: string,
    abiPath: string,
    client,
    keys: any,
    noPath = false
  ) {
    // read contract .tvc file
    let imageBase64 = '';
    if (!noPath) {
      const buff = readFileSync(resolve(contractPath));
      // convert tvc code into base64
      imageBase64 = buff.toString('base64');
    }

    // eslint-disable-next-line @typescript-eslint/no-var-requires
    const abi = require(resolve(abiPath));
    this.contractPackage = { abi, imageBase64 };
    this.client = client;
    this.keys = keys;
    this.isDeployed = false;
  }

  public async deployContract(constructorParams = {}, giveGram = true, keys?) {
    this.address = await deploy(
      this.client,
      this.contractPackage,
      keys || this.keys,
      constructorParams,
      {},
      {},
      giveGram
    );
    this.isDeployed = true;
  }

  public async complicatedDeploy(
    constructorParams = {},
    constructorHeader = {},
    initParams = {},
    giveGram = true,
    keys?
  ) {
    this.address = await deploy(
      this.client,
      this.contractPackage,
      keys || this.keys,
      constructorParams,
      constructorHeader,
      initParams,
      giveGram
    );
    this.isDeployed = true;
  }

  public async runWithMessage(functionName, input, keyPair?) {
    if (!this.isDeployed) {
      throw new Error('Contract not deployed');
    }
    if (!keyPair) {
      keyPair = this.keys;
    }
    const runMessage = await this.client.contracts.createRunMessage({
      address: this.address,
      abi: this.contractPackage.abi,
      functionName,
      input,
      keyPair,
    });
    const messageProcessingState = await this.client.contracts.sendMessage(
      runMessage.message
    );
    const result = await this.client.contracts.waitForRunTransaction(
      runMessage,
      messageProcessingState
    );
    return result;
  }

  public async runLocal(functionName, input, keyPair?) {
    if (!this.isDeployed) {
      throw new Error('Contract not deployed');
    }
    if (!keyPair) {
      keyPair = this.keys;
    }
    const response = await this.client.contracts.runLocal({
      address: this.address,
      abi: this.contractPackage.abi,
      functionName,
      input,
      keyPair,
    });
    return response;
  }

  public async futureAddress() {
    const futureAddress = (
      await this.client.contracts.getDeployData({
        abi: this.contractPackage.abi,
        imageBase64: this.contractPackage.imageBase64,
        publicKeyHex: this.keys.public,
      })
    ).address;
    return futureAddress;
  }
  public async runContract(functionName, input, keyPair?) {
    if (!this.isDeployed) {
      throw new Error('Contract not deployed');
    }
    if (!keyPair) {
      keyPair = this.keys;
    }
    const response = await this.client.contracts.run({
      address: this.address,
      abi: this.contractPackage.abi,
      functionName: functionName,
      input: input,
      keyPair: keyPair, //there is no pubkey key check in the contract so we can leave it empty
    });
    return response.output;
  }
}