@alephium/web3 0.0.1-test.0

package/dist/src/contract/contract.d.ts

@@ -0,0 +1,182 @@
+import { NodeProvider } from '../api';
+import { node } from '../api';
+import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+export declare abstract class Common {
+    readonly sourceCodeSha256: string;
+    readonly functions: node.FunctionSig[];
+    static readonly importRegex: RegExp;
+    static readonly contractRegex: RegExp;
+    static readonly interfaceRegex: RegExp;
+    static readonly scriptRegex: RegExp;
+    private static _artifactCache;
+    static artifactCacheCapacity: number;
+    protected static _getArtifactFromCache(codeHash: string): Contract | Script | undefined;
+    protected static _putArtifactToCache(contract: Contract): void;
+    constructor(sourceCodeSha256: string, functions: node.FunctionSig[]);
+    protected static _contractPath(fileName: string): string;
+    protected static _artifactPath(fileName: string): string;
+    protected static _artifactsFolder(): string;
+    protected static _handleImports(contractStr: string, importsCache: string[]): Promise<string>;
+    protected static _loadContractStr(fileName: string, importsCache: string[], validate: (fileName: string) => void): Promise<string>;
+    static checkFileNameExtension(fileName: string): void;
+    protected static _from<T extends {
+        sourceCodeSha256: string;
+    }>(provider: NodeProvider, fileName: string, loadContractStr: (fileName: string, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, fileName: string, contractStr: string, contractHash: string) => Promise<T>): Promise<T>;
+    protected _saveToFile(fileName: string): Promise<void>;
+    abstract buildByteCodeToDeploy(initialFields?: Fields): string;
+}
+export declare class Contract extends Common {
+    readonly bytecode: string;
+    readonly codeHash: string;
+    readonly fieldsSig: node.FieldsSig;
+    readonly eventsSig: node.EventSig[];
+    constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: node.FieldsSig, eventsSig: node.EventSig[], functions: node.FunctionSig[]);
+    static checkCodeType(fileName: string, contractStr: string): void;
+    private static loadContractStr;
+    static fromSource(provider: NodeProvider, fileName: string): Promise<Contract>;
+    private static compile;
+    static fromJson(artifact: any): Contract;
+    static fromArtifactFile(fileName: string): Promise<Contract>;
+    toString(): string;
+    toState(fields: Fields, asset: Asset, address?: string): ContractState;
+    static randomAddress(): string;
+    private _test;
+    testPublicMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    testPrivateMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    toApiFields(fields?: Fields): node.Val[];
+    toApiArgs(funcName: string, args?: Arguments): node.Val[];
+    getMethodIndex(funcName: string): number;
+    toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
+    toTestContract(funcName: string, params: TestContractParams): node.TestContract;
+    static fromCodeHash(codeHash: string): Promise<Contract>;
+    static getFieldsSig(state: node.ContractState): Promise<node.FieldsSig>;
+    fromApiContractState(state: node.ContractState): Promise<ContractState>;
+    static ContractCreatedEvent: node.EventSig;
+    static ContractDestroyedEvent: node.EventSig;
+    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): Promise<ContractEventByTxId>;
+    fromTestContractResult(methodIndex: number, result: node.TestContractResult): Promise<TestContractResult>;
+    paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams>;
+    transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
+    buildByteCodeToDeploy(initialFields: Fields): string;
+}
+export declare class Script extends Common {
+    readonly bytecodeTemplate: string;
+    readonly fieldsSig: node.FieldsSig;
+    constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: node.FieldsSig, functions: node.FunctionSig[]);
+    static checkCodeType(fileName: string, contractStr: string): void;
+    private static loadContractStr;
+    static fromSource(provider: NodeProvider, fileName: string): Promise<Script>;
+    private static compile;
+    static fromJson(artifact: any): Script;
+    static fromArtifactFile(fileName: string): Promise<Script>;
+    toString(): string;
+    paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams>;
+    transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
+    buildByteCodeToDeploy(initialFields: Fields): string;
+}
+export declare type Number256 = number | bigint | string;
+export declare type Val = Number256 | boolean | string | Val[];
+export declare type NamedVals = Record<string, Val>;
+export declare type Fields = NamedVals;
+export declare type Arguments = NamedVals;
+export declare function extractArray(tpe: string, v: Val): node.Val;
+export declare function toApiVal(v: Val, tpe: string): node.Val;
+export interface Asset {
+    alphAmount: Number256;
+    tokens?: Token[];
+}
+export interface Token {
+    id: string;
+    amount: Number256;
+}
+export interface InputAsset {
+    address: string;
+    asset: Asset;
+}
+export interface ContractState {
+    address: string;
+    contractId: string;
+    bytecode: string;
+    initialStateHash?: string;
+    codeHash: string;
+    fields: Fields;
+    fieldsSig: node.FieldsSig;
+    asset: Asset;
+}
+export interface TestContractParams {
+    group?: number;
+    address?: string;
+    initialFields?: Fields;
+    initialAsset?: Asset;
+    testMethodIndex?: number;
+    testArgs?: Arguments;
+    existingContracts?: ContractState[];
+    inputAssets?: InputAsset[];
+}
+export interface ContractEvent {
+    blockHash: string;
+    txId: string;
+    name: string;
+    fields: Fields;
+}
+export interface ContractEventByTxId {
+    blockHash: string;
+    contractAddress: string;
+    name: string;
+    fields: Fields;
+}
+export interface TestContractResult {
+    address: string;
+    contractId: string;
+    returns: Val[];
+    gasUsed: number;
+    contracts: ContractState[];
+    txOutputs: Output[];
+    events: ContractEventByTxId[];
+}
+export declare type Output = AssetOutput | ContractOutput;
+export interface AssetOutput extends Asset {
+    type: string;
+    address: string;
+    lockTime: number;
+    message: string;
+}
+export interface ContractOutput {
+    type: string;
+    address: string;
+    alphAmount: Number256;
+    tokens: Token[];
+}
+export interface DeployContractTransaction {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    contractAddress: string;
+    contractId: string;
+}
+export interface BuildDeployContractTx {
+    signerAddress: string;
+    initialFields?: Fields;
+    initialAttoAlphAmount?: string;
+    initialTokenAmounts?: Token[];
+    issueTokenAmount?: Number256;
+    gasAmount?: number;
+    gasPrice?: Number256;
+    submitTx?: boolean;
+}
+export interface BuildExecuteScriptTx {
+    signerAddress: string;
+    initialFields?: Fields;
+    attoAlphAmount?: Number256;
+    tokens?: Token[];
+    gasAmount?: number;
+    gasPrice?: Number256;
+    submitTx?: boolean;
+}
+export interface BuildScriptTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+}