@alephium/web3 0.41.0 → 0.43.0

package/dist/src/codec/token-codec.js

@@ -18,10 +18,10 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokensCodec = exports.tokenCodec = exports.TokenCodec = void 0;
-const buffer_1 = require("buffer/");
 const binary_parser_1 = require("binary-parser");
 const compact_int_codec_1 = require("./compact-int-codec");
 const array_codec_1 = require("./array-codec");
+const utils_1 = require("../utils");
 class TokenCodec {
     constructor() {
         this.parser = binary_parser_1.Parser.start()
@@ -34,8 +34,8 @@ class TokenCodec {
     }
     encode(input) {
         const tokenId = input.tokenId;
-        const amount = buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount));
-        return buffer_1.Buffer.concat([tokenId, amount]);
+        const amount = compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount);
+        return (0, utils_1.concatBytes)([tokenId, amount]);
     }
     decode(input) {
         return this.parser.parse(input);

package/dist/src/codec/transaction-codec.d.ts

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { UnsignedTx } from './unsigned-tx-codec';
@@ -17,10 +16,10 @@ export interface Transaction {
 }
 export declare class TransactionCodec implements Codec<Transaction> {
     parser: Parser;
-    encode(decodedTx: Transaction): Buffer;
-    decode(input: Buffer): Transaction;
-    encodeApiTransaction(input: ApiTransaction): Buffer;
-    decodeApiTransaction(input: Buffer): ApiTransaction;
+    encode(decodedTx: Transaction): Uint8Array;
+    decode(input: Uint8Array): Transaction;
+    encodeApiTransaction(input: ApiTransaction): Uint8Array;
+    decodeApiTransaction(input: Uint8Array): ApiTransaction;
     static toApiTransaction(transaction: Transaction): ApiTransaction;
     static fromApiTransaction(tx: ApiTransaction): Transaction;
 }

package/dist/src/codec/transaction-codec.js

@@ -18,7 +18,6 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transactionCodec = exports.TransactionCodec = void 0;
-const buffer_1 = require("buffer/");
 const binary_parser_1 = require("binary-parser");
 const unsigned_tx_codec_1 = require("./unsigned-tx-codec");
 const signature_codec_1 = require("./signature-codec");
@@ -48,13 +47,13 @@ class TransactionCodec {
         });
     }
     encode(decodedTx) {
-        return buffer_1.Buffer.concat([
+        return (0, utils_1.concatBytes)([
             unsigned_tx_codec_1.unsignedTxCodec.encode(decodedTx.unsigned),
-            buffer_1.Buffer.from([decodedTx.scriptExecutionOk]),
-            buffer_1.Buffer.from([...contract_output_ref_codec_1.contractOutputRefsCodec.encode(decodedTx.contractInputs.value)]),
-            buffer_1.Buffer.from([...output_codec_1.outputsCodec.encode(decodedTx.generatedOutputs.value)]),
-            buffer_1.Buffer.from([...signature_codec_1.signaturesCodec.encode(decodedTx.inputSignatures.value)]),
-            buffer_1.Buffer.from([...signature_codec_1.signaturesCodec.encode(decodedTx.scriptSignatures.value)])
+            new Uint8Array([decodedTx.scriptExecutionOk]),
+            contract_output_ref_codec_1.contractOutputRefsCodec.encode(decodedTx.contractInputs.value),
+            output_codec_1.outputsCodec.encode(decodedTx.generatedOutputs.value),
+            signature_codec_1.signaturesCodec.encode(decodedTx.inputSignatures.value),
+            signature_codec_1.signaturesCodec.encode(decodedTx.scriptSignatures.value)
         ]);
     }
     decode(input) {
@@ -74,7 +73,7 @@ class TransactionCodec {
         const scriptExecutionOk = !!transaction.scriptExecutionOk;
         const contractInputs = transaction.contractInputs.value.map((contractInput) => {
             const hint = contractInput.hint;
-            const key = contractInput.key.toString('hex');
+            const key = (0, utils_1.binToHex)(contractInput.key);
             return { hint, key };
         });
         const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
@@ -87,15 +86,15 @@ class TransactionCodec {
                 return contract_output_codec_1.ContractOutputCodec.convertToApiContractOutput(txIdBytes, output.value, index);
             }
         });
-        const inputSignatures = transaction.inputSignatures.value.map((signature) => signature.value.toString('hex'));
-        const scriptSignatures = transaction.scriptSignatures.value.map((signature) => signature.value.toString('hex'));
+        const inputSignatures = transaction.inputSignatures.value.map((signature) => (0, utils_1.binToHex)(signature.value));
+        const scriptSignatures = transaction.scriptSignatures.value.map((signature) => (0, utils_1.binToHex)(signature.value));
         return { unsigned, scriptExecutionOk, contractInputs, generatedOutputs, inputSignatures, scriptSignatures };
     }
     static fromApiTransaction(tx) {
         const unsigned = unsigned_tx_codec_1.UnsignedTxCodec.fromApiUnsignedTx(tx.unsigned);
         const scriptExecutionOk = tx.scriptExecutionOk ? 1 : 0;
         const contractInputs = tx.contractInputs.map((contractInput) => {
-            return { hint: contractInput.hint, key: buffer_1.Buffer.from(contractInput.key, 'hex') };
+            return { hint: contractInput.hint, key: (0, utils_1.hexToBinUnsafe)(contractInput.key) };
         });
         const generatedOutputs = tx.generatedOutputs.map((output) => {
             if (output.type === 'AssetOutput') {
@@ -109,10 +108,10 @@ class TransactionCodec {
             }
         });
         const inputSignatures = tx.inputSignatures.map((signature) => {
-            return { value: buffer_1.Buffer.from(signature, 'hex') };
+            return { value: (0, utils_1.hexToBinUnsafe)(signature) };
         });
         const scriptSignatures = tx.scriptSignatures.map((signature) => {
-            return { value: buffer_1.Buffer.from(signature, 'hex') };
+            return { value: (0, utils_1.hexToBinUnsafe)(signature) };
         });
         return {
             unsigned,

package/dist/src/codec/unlock-script-codec.d.ts

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { DecodedCompactInt } from './compact-int-codec';
@@ -7,7 +6,7 @@ import { DecodedScript } from './script-codec';
 import { ByteString } from './bytestring-codec';
 import { LockupScript } from './lockup-script-codec';
 export interface P2PKH {
-    publicKey: Buffer;
+    publicKey: Uint8Array;
 }
 export interface P2MPKH {
     publicKeys: DecodedArray<{
@@ -25,8 +24,8 @@ export interface P2SH {
 }
 export declare class P2SHCodec implements Codec<P2SH> {
     parser: Parser;
-    encode(input: P2SH): Buffer;
-    decode(input: Buffer): P2SH;
+    encode(input: P2SH): Uint8Array;
+    decode(input: Uint8Array): P2SH;
 }
 export interface UnlockScript {
     scriptType: number;
@@ -34,7 +33,7 @@ export interface UnlockScript {
 }
 export declare class UnlockScriptCodec implements Codec<UnlockScript> {
     parser: Parser;
-    encode(input: UnlockScript): Buffer;
-    decode(input: Buffer): UnlockScript;
+    encode(input: UnlockScript): Uint8Array;
+    decode(input: Uint8Array): UnlockScript;
 }
 export declare const unlockScriptCodec: UnlockScriptCodec;

package/dist/src/codec/unlock-script-codec.js

@@ -18,13 +18,13 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-const buffer_1 = require("buffer/");
 const binary_parser_1 = require("binary-parser");
 const array_codec_1 = require("./array-codec");
 const compact_int_codec_1 = require("./compact-int-codec");
 const script_codec_1 = require("./script-codec");
 const bytestring_codec_1 = require("./bytestring-codec");
 const lockup_script_codec_1 = require("./lockup-script-codec");
+const utils_1 = require("../utils");
 class P2PKHCodec {
     constructor() {
         this.parser = binary_parser_1.Parser.start().buffer('publicKey', { length: 33 });
@@ -46,10 +46,10 @@ class P2MPKHCodec {
         });
     }
     encode(input) {
-        return buffer_1.Buffer.concat([
-            buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length)),
+        return (0, utils_1.concatBytes)([
+            compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length),
             ...input.publicKeys.value.map((v) => {
-                return buffer_1.Buffer.concat([v.publicKey.publicKey, buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(v.index))]);
+                return (0, utils_1.concatBytes)([v.publicKey.publicKey, compact_int_codec_1.compactUnsignedIntCodec.encode(v.index)]);
             })
         ]);
     }
@@ -77,23 +77,23 @@ class ValCodec {
         const valType = input.type;
         if (valType === 0x00) {
             // Boolean
-            return buffer_1.Buffer.from([valType, input.val]);
+            return new Uint8Array([valType, input.val]);
         }
         else if (valType === 0x01) {
             // I256
-            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
         }
         else if (valType === 0x02) {
             // U256
-            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
         }
         else if (valType === 0x03) {
             // ByteVec
-            return buffer_1.Buffer.from([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
         }
         else if (valType === 0x04) {
             // Address
-            return buffer_1.Buffer.from([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
         }
         else {
             throw new Error(`ValCodec: unsupported val type: ${valType}`);
@@ -116,7 +116,7 @@ class P2SHCodec {
         });
     }
     encode(input) {
-        return buffer_1.Buffer.concat([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
+        return (0, utils_1.concatBytes)([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
     }
     decode(input) {
         return this.parser.parse(input);
@@ -141,22 +141,21 @@ class UnlockScriptCodec {
     encode(input) {
         const scriptType = input.scriptType;
         const inputUnLockScript = input.script;
-        const inputUnLockScriptType = buffer_1.Buffer.from([scriptType]);
         if (scriptType === 0) {
             // P2PKH
-            return buffer_1.Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript)]);
+            return new Uint8Array([scriptType, ...p2pkhCodec.encode(inputUnLockScript)]);
         }
         else if (scriptType === 1) {
             // P2MPKH
-            return buffer_1.Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript)]);
+            return new Uint8Array([scriptType, ...p2mpkhCodec.encode(inputUnLockScript)]);
         }
         else if (scriptType === 2) {
             // P2SH
-            return buffer_1.Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script)]);
+            return new Uint8Array([scriptType, ...p2shCodec.encode(inputUnLockScript)]);
         }
         else if (scriptType === 3) {
             // SameAsPrevious
-            return inputUnLockScriptType;
+            return new Uint8Array([scriptType]);
         }
         else {
             throw new Error(`TODO: encode unlock script: ${scriptType}`);

package/dist/src/codec/unsigned-tx-codec.d.ts

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium';
 import { DecodedScript } from './script-codec';
@@ -19,10 +18,10 @@ export interface UnsignedTx {
 }
 export declare class UnsignedTxCodec implements Codec<UnsignedTx> {
     parser: Parser;
-    encode(decodedUnsignedTx: UnsignedTx): Buffer;
-    decode(input: Buffer): UnsignedTx;
-    encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer;
-    decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx;
+    encode(decodedUnsignedTx: UnsignedTx): Uint8Array;
+    decode(input: Uint8Array): UnsignedTx;
+    encodeApiUnsignedTx(input: ApiUnsignedTx): Uint8Array;
+    decodeApiUnsignedTx(input: Uint8Array): ApiUnsignedTx;
     static txId(unsignedTx: UnsignedTx): string;
     static toApiUnsignedTx(unsigned: UnsignedTx): ApiUnsignedTx;
     static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx;

package/dist/src/codec/unsigned-tx-codec.js

@@ -18,7 +18,6 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-const buffer_1 = require("buffer/");
 const binary_parser_1 = require("binary-parser");
 const utils_1 = require("../utils");
 const script_codec_1 = require("./script-codec");
@@ -48,8 +47,8 @@ class UnsignedTxCodec {
         });
     }
     encode(decodedUnsignedTx) {
-        return buffer_1.Buffer.concat([
-            buffer_1.Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
+        return (0, utils_1.concatBytes)([
+            new Uint8Array([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
             script_codec_1.statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
             compact_int_codec_1.compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
             compact_int_codec_1.compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
@@ -82,7 +81,7 @@ class UnsignedTxCodec {
         const fixedOutputs = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value);
         let scriptOpt = undefined;
         if (unsigned.statefulScript.option === 1) {
-            scriptOpt = script_codec_1.scriptCodec.encode(unsigned.statefulScript.value).toString('hex');
+            scriptOpt = (0, utils_1.binToHex)(script_codec_1.scriptCodec.encode(unsigned.statefulScript.value));
         }
         return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs };
     }
@@ -95,7 +94,7 @@ class UnsignedTxCodec {
         const inputs = input_codec_1.inputsCodec.fromArray(inputsValue);
         const fixedOutputsValue = asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs);
         const fixedOutputs = asset_output_codec_1.assetOutputsCodec.fromArray(fixedOutputsValue);
-        const statefulScript = script_codec_1.statefulScriptCodecOpt.fromBuffer(unsignedTx.scriptOpt ? buffer_1.Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined);
+        const statefulScript = script_codec_1.statefulScriptCodecOpt.fromBytes(unsignedTx.scriptOpt ? (0, utils_1.hexToBinUnsafe)(unsignedTx.scriptOpt) : undefined);
         return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript };
     }
 }

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

@@ -12,60 +12,11 @@ export type Arguments = NamedVals;
 export type Constant = node.Constant;
 export type Enum = node.Enum;
 export declare const StdIdFieldName = "__stdInterfaceId";
-declare enum SourceKind {
-    Contract = 0,
-    Script = 1,
-    AbstractContract = 2,
-    Interface = 3,
-    Struct = 4
-}
 export type CompilerOptions = node.CompilerOptions & {
     errorOnWarnings: boolean;
 };
 export declare const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions;
 export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
-declare class TypedMatcher<T extends SourceKind> {
-    matcher: RegExp;
-    type: T;
-    constructor(pattern: string, type: T);
-}
-declare class SourceInfo {
-    type: SourceKind;
-    name: string;
-    contractRelativePath: string;
-    sourceCode: string;
-    sourceCodeHash: string;
-    isExternal: boolean;
-    getArtifactPath(artifactsRootDir: string): string;
-    constructor(type: SourceKind, name: string, sourceCode: string, sourceCodeHash: string, contractRelativePath: string, isExternal: boolean);
-    static from(type: SourceKind, name: string, sourceCode: string, contractRelativePath: string, isExternal: boolean): Promise<SourceInfo>;
-}
-declare class Compiled<T extends Artifact> {
-    sourceInfo: SourceInfo;
-    artifact: T;
-    warnings: string[];
-    constructor(sourceInfo: SourceInfo, artifact: T, warnings: string[]);
-}
-type CodeInfo = {
-    sourceFile: string;
-    sourceCodeHash: string;
-    bytecodeDebugPatch: string;
-    codeHashDebug: string;
-    warnings: string[];
-};
-export declare class ProjectArtifact {
-    static readonly artifactFileName = ".project.json";
-    fullNodeVersion: string;
-    compilerOptionsUsed: node.CompilerOptions;
-    infos: Map<string, CodeInfo>;
-    static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void;
-    constructor(fullNodeVersion: string, compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
-    static isCodeChanged(current: ProjectArtifact, previous: ProjectArtifact): boolean;
-    saveToFile(rootPath: string): Promise<void>;
-    getChangedSources(sourceInfos: SourceInfo[]): SourceInfo[];
-    needToReCompile(compilerOptions: node.CompilerOptions, fullNodeVersion: string): boolean;
-    static from(rootPath: string): Promise<ProjectArtifact | undefined>;
-}
 export declare class Struct {
     name: string;
     fieldNames: string[];
@@ -76,43 +27,6 @@ export declare class Struct {
     static fromStructSig(sig: node.StructSig): Struct;
     toJson(): any;
 }
-export declare class Project {
-    sourceInfos: SourceInfo[];
-    contracts: Map<string, Compiled<Contract>>;
-    scripts: Map<string, Compiled<Script>>;
-    structs: Struct[];
-    projectArtifact: ProjectArtifact;
-    readonly contractsRootDir: string;
-    readonly artifactsRootDir: string;
-    static currentProject: Project;
-    static readonly importRegex: RegExp;
-    static readonly abstractContractMatcher: TypedMatcher<SourceKind>;
-    static readonly contractMatcher: TypedMatcher<SourceKind.Contract>;
-    static readonly interfaceMatcher: TypedMatcher<SourceKind.Interface>;
-    static readonly scriptMatcher: TypedMatcher<SourceKind.Script>;
-    static readonly structMatcher: TypedMatcher<SourceKind.Struct>;
-    static readonly matchers: TypedMatcher<SourceKind>[];
-    static buildProjectArtifact(fullNodeVersion: string, sourceInfos: SourceInfo[], contracts: Map<string, Compiled<Contract>>, scripts: Map<string, Compiled<Script>>, compilerOptions: node.CompilerOptions): ProjectArtifact;
-    private constructor();
-    static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
-    static contract(name: string): Contract;
-    static script(name: string): Script;
-    private static loadStructs;
-    private saveStructsToFile;
-    private saveArtifactsToFile;
-    private saveProjectArtifact;
-    contractByCodeHash(codeHash: string): Contract;
-    private static getCompileResult;
-    private static compile;
-    private static loadArtifacts;
-    private static getImportSourcePath;
-    private static handleImports;
-    private static loadSourceFile;
-    private static loadSourceFiles;
-    static readonly DEFAULT_CONTRACTS_DIR = "contracts";
-    static readonly DEFAULT_ARTIFACTS_DIR = "artifacts";
-    static build(compilerOptionsPartial?: Partial<CompilerOptions>, projectRootDir?: string, contractsRootDir?: string, artifactsRootDir?: string, defaultFullNodeVersion?: string | undefined, skipSaveArtifacts?: boolean): Promise<void>;
-}
 export declare abstract class Artifact {
     readonly version: string;
     readonly name: string;
@@ -153,18 +67,18 @@ export declare class Contract extends Artifact {
     toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
     toApiTestContractParams(funcName: string, params: TestContractParams): node.TestContract;
     fromApiContractState(state: node.ContractState): ContractState<Fields>;
-    static fromApiContractState(state: node.ContractState, getContractByCodeHash?: (codeHash: string) => Contract): ContractState;
+    static fromApiContractState(state: node.ContractState, getContractByCodeHash: (codeHash: string) => Contract): ContractState;
     static ContractCreatedEventIndex: number;
     static ContractCreatedEvent: EventSig;
     static ContractDestroyedEventIndex: number;
     static ContractDestroyedEvent: EventSig;
-    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string, getContractByCodeHash?: (codeHash: string) => Contract): ContractEvent;
-    fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string): TestContractResult<unknown>;
+    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent;
+    fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string, getContractByCodeHash: (codeHash: string) => Contract): TestContractResult<unknown>;
     txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>): Promise<SignDeployContractTxParams>;
     buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string;
-    static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string, getContractByCodeHash?: (codeHash: string) => Contract): ContractEvent[];
+    static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent[];
     toApiCallContract<T extends Arguments>(params: CallContractParams<T>, groupIndex: number, contractAddress: string, methodIndex: number): node.CallContract;
-    fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number, getContractByCodeHash?: (codeHash: string) => Contract): CallContractResult<unknown>;
+    fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number, getContractByCodeHash: (codeHash: string) => Contract): CallContractResult<unknown>;
 }
 export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
@@ -324,7 +238,7 @@ export declare function subscribeEventsFromContract<T extends Fields, M extends
 export declare function addStdIdToFields<F extends Fields>(contract: Contract, fields: F): F | (F & {
     __stdInterfaceId: HexString;
 });
-export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>>(factory: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R, M>>;
+export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>>(factory: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<TestContractResult<R, M>>;
 export declare class RalphMap<K extends Val, V extends Val> {
     private readonly parentContract;
     private readonly parentContractId;
@@ -352,9 +266,8 @@ export declare function subscribeContractDestroyedEvent(options: EventSubscribeO
 export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, event: node.ContractEvent, targetEventIndex: number): M;
 export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
 export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
-export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
-export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
+export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
+export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
 export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export declare const getContractIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;
 export declare const getTokenIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;
-export {};