@alephium/web3 0.40.0 → 0.41.0

package/dist/src/api/node-provider.d.ts

@@ -1,6 +1,7 @@
 import { ApiRequestArguments, ApiRequestHandler, FungibleTokenMetaData, NFTMetaData, NFTCollectionMetaData } from './types';
 import { Api as NodeApi } from './api-alephium';
 import { HexString } from '../utils';
+import * as node from '../api/api-alephium';
 interface NodeProviderApis {
     wallets: NodeApi<string>['wallets'];
     infos: NodeApi<string>['infos'];
@@ -41,4 +42,5 @@ export declare class NodeProvider implements NodeProviderApis {
     guessFollowsNFTCollectionWithRoyaltyStd: (contractId: HexString) => Promise<boolean>;
     guessStdTokenType: (tokenId: HexString) => Promise<'fungible' | 'non-fungible' | undefined>;
 }
+export declare function tryGetCallResult(result: node.CallContractResult): node.CallContractSucceeded;
 export {};

package/dist/src/api/node-provider.js

@@ -17,10 +17,9 @@ 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/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeProvider = void 0;
+exports.tryGetCallResult = exports.NodeProvider = void 0;
 const types_1 = require("./types");
 const api_alephium_1 = require("./api-alephium");
-const contract_1 = require("../contract");
 const utils_1 = require("../utils");
 function initializeNodeApi(baseUrl, apiKey, customFetch) {
     const nodeApi = new api_alephium_1.Api({
@@ -45,7 +44,7 @@ class NodeProvider {
             const result = await this.contracts.postContractsMulticallContract({
                 calls: calls
             });
-            const callResults = result.results.map((r) => (0, contract_1.tryGetCallResult)(r));
+            const callResults = result.results.map((r) => tryGetCallResult(r));
             return {
                 symbol: callResults[0].returns[0].value,
                 name: callResults[1].returns[0].value,
@@ -61,7 +60,7 @@ class NodeProvider {
             const result = await this.contracts.postContractsMulticallContract({
                 calls: calls
             });
-            const tokenUri = (0, utils_1.hexToString)((0, contract_1.tryGetCallResult)(result.results[0]).returns[0].value);
+            const tokenUri = (0, utils_1.hexToString)(tryGetCallResult(result.results[0]).returns[0].value);
             const collectionIndexResult = result.results[1];
             if (collectionIndexResult.type === 'CallContractSucceeded') {
                 const successfulCollectionIndexResult = result.results[1];
@@ -104,7 +103,7 @@ class NodeProvider {
             const group = (0, utils_1.groupOfAddress)(address);
             const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }));
             const result = await this.contracts.postContractsMulticallContract({ calls });
-            const callResults = result.results.map((r) => (0, contract_1.tryGetCallResult)(r));
+            const callResults = result.results.map((r) => tryGetCallResult(r));
             return {
                 collectionUri: (0, utils_1.hexToString)(callResults[0].returns[0].value),
                 totalSupply: BigInt(callResults[1].returns[0].value)
@@ -129,7 +128,7 @@ class NodeProvider {
                     }
                 ]
             });
-            const result = (0, contract_1.tryGetCallResult)(apiResult);
+            const result = tryGetCallResult(apiResult);
             return BigInt(result.returns[0].value);
         };
         this.guessStdInterfaceId = async (tokenId) => {
@@ -196,3 +195,10 @@ class NodeProvider {
     }
 }
 exports.NodeProvider = NodeProvider;
+function tryGetCallResult(result) {
+    if (result.type === 'CallContractFailed') {
+        throw new Error(`Failed to call contract, error: ${result.error}`);
+    }
+    return result;
+}
+exports.tryGetCallResult = tryGetCallResult;

package/dist/src/api/utils.d.ts

@@ -1,5 +1,5 @@
 import 'cross-fetch/polyfill';
-import { node } from '..';
+import * as node from '../api/api-alephium';
 export declare function convertHttpResponse<T>(response: {
     status: number;
     data: T;

package/dist/src/block/block.d.ts

@@ -0,0 +1,28 @@
+import { Subscription, SubscribeOptions } from '../utils/subscription';
+import * as node from '../api/api-alephium';
+import { NodeProvider } from '../api';
+export type ReorgCallback = (orphanBlocks: node.BlockEntry[], newBlocks: node.BlockEntry[]) => Promise<void> | void;
+export interface BlockSubscribeOptions extends SubscribeOptions<node.BlockEntry> {
+    reorgCallback?: ReorgCallback;
+}
+export declare abstract class BlockSubscriptionBase extends Subscription<node.BlockEntry> {
+    abstract readonly reorgCallback?: ReorgCallback;
+    abstract readonly fromGroup: number;
+    abstract readonly toGroup: number;
+    abstract getHashesAtHeight(height: number): Promise<string[]>;
+    abstract getBlockByHash(hash: string): Promise<node.BlockEntry>;
+    protected getParentHash(block: node.BlockEntry): string;
+    protected handleReorg(blockHash: string, blockHeight: number): Promise<void>;
+}
+export declare class BlockSubscription extends BlockSubscriptionBase {
+    readonly nodeProvider: NodeProvider;
+    readonly fromGroup: number;
+    readonly toGroup: number;
+    readonly reorgCallback?: ReorgCallback;
+    private currentBlockHeight;
+    private parentBlockHash;
+    constructor(options: BlockSubscribeOptions, fromGroup: number, toGroup: number, fromBlockHeight: number, nodeProvider?: NodeProvider | undefined);
+    getHashesAtHeight(height: number): Promise<string[]>;
+    getBlockByHash(hash: string): Promise<node.BlockEntry>;
+    polling(): Promise<void>;
+}

package/dist/src/block/block.js

@@ -0,0 +1,131 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockSubscription = exports.BlockSubscriptionBase = void 0;
+const subscription_1 = require("../utils/subscription");
+const web3 = __importStar(require("../global"));
+class BlockSubscriptionBase extends subscription_1.Subscription {
+    getParentHash(block) {
+        const index = Math.floor(block.deps.length / 2) + this.toGroup;
+        return block.deps[index];
+    }
+    async handleReorg(blockHash, blockHeight) {
+        console.info(`reorg occur, hash: ${blockHash}, height: ${blockHeight}`);
+        if (this.reorgCallback === undefined)
+            return;
+        const orphans = [];
+        const newHashes = [];
+        let fromHash = blockHash;
+        let fromHeight = blockHeight;
+        while (true) {
+            const hashes = await this.getHashesAtHeight(fromHeight);
+            const canonicalHash = hashes[0];
+            if (canonicalHash !== fromHash) {
+                orphans.push(fromHash);
+                newHashes.push(canonicalHash);
+                const block = await this.getBlockByHash(fromHash);
+                fromHash = this.getParentHash(block);
+                fromHeight -= 1;
+            }
+            else {
+                break;
+            }
+        }
+        const orphanBlocks = [];
+        for (const hash of orphans.reverse()) {
+            const block = await this.getBlockByHash(hash);
+            orphanBlocks.push(block);
+        }
+        const newBlocks = [];
+        for (const hash of newHashes.reverse()) {
+            const block = await this.getBlockByHash(hash);
+            newBlocks.push(block);
+        }
+        console.info(`orphan hashes: ${orphanBlocks.map((b) => b.hash)}, new hashes: ${newBlocks.map((b) => b.hash)}`);
+        await this.reorgCallback(orphanBlocks, newBlocks);
+    }
+}
+exports.BlockSubscriptionBase = BlockSubscriptionBase;
+class BlockSubscription extends BlockSubscriptionBase {
+    constructor(options, fromGroup, toGroup, fromBlockHeight, nodeProvider = undefined) {
+        super(options);
+        this.nodeProvider = nodeProvider ?? web3.getCurrentNodeProvider();
+        this.fromGroup = fromGroup;
+        this.toGroup = toGroup;
+        this.reorgCallback = options.reorgCallback;
+        this.currentBlockHeight = fromBlockHeight;
+        this.parentBlockHash = undefined;
+    }
+    async getHashesAtHeight(height) {
+        const result = await this.nodeProvider.blockflow.getBlockflowHashes({
+            fromGroup: this.fromGroup,
+            toGroup: this.toGroup,
+            height
+        });
+        return result.headers;
+    }
+    async getBlockByHash(hash) {
+        return await this.nodeProvider.blockflow.getBlockflowBlocksBlockHash(hash);
+    }
+    async polling() {
+        try {
+            const chainInfo = await this.nodeProvider.blockflow.getBlockflowChainInfo({
+                fromGroup: this.fromGroup,
+                toGroup: this.toGroup
+            });
+            while (this.currentBlockHeight <= chainInfo.currentHeight) {
+                const hashes = await this.getHashesAtHeight(this.currentBlockHeight);
+                const block = await this.getBlockByHash(hashes[0]);
+                if (this.parentBlockHash !== undefined && this.getParentHash(block) !== this.parentBlockHash) {
+                    await this.handleReorg(this.parentBlockHash, this.currentBlockHeight - 1);
+                }
+                await this.messageCallback(block);
+                this.currentBlockHeight += 1;
+                this.parentBlockHash = hashes[0];
+            }
+        }
+        catch (err) {
+            await this.errorCallback(err, this);
+        }
+    }
+}
+exports.BlockSubscription = BlockSubscription;

package/dist/src/block/index.d.ts

@@ -0,0 +1 @@
+export { ReorgCallback, BlockSubscribeOptions, BlockSubscription } from './block';

package/dist/src/block/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockSubscription = void 0;
+var block_1 = require("./block");
+Object.defineProperty(exports, "BlockSubscription", { enumerable: true, get: function () { return block_1.BlockSubscription; } });

package/dist/src/codec/contract-output-codec.js

@@ -23,7 +23,7 @@ const binary_parser_1 = require("binary-parser");
 const compact_int_codec_1 = require("./compact-int-codec");
 const token_codec_1 = require("./token-codec");
 const hash_1 = require("./hash");
-const __1 = require("..");
+const utils_1 = require("../utils");
 const signed_int_codec_1 = require("./signed-int-codec");
 const lockup_script_codec_1 = require("./lockup-script-codec");
 class ContractOutputCodec {
@@ -50,9 +50,9 @@ class ContractOutputCodec {
     }
     static convertToApiContractOutput(txIdBytes, output, index) {
         const hint = (0, hash_1.createHint)(output.lockupScript.contractId);
-        const key = (0, __1.binToHex)((0, hash_1.blakeHash)(buffer_1.Buffer.concat([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
+        const key = (0, utils_1.binToHex)((0, hash_1.blakeHash)(buffer_1.Buffer.concat([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
         const attoAlphAmount = compact_int_codec_1.compactUnsignedIntCodec.toU256(output.amount).toString();
-        const address = __1.bs58.encode(buffer_1.Buffer.concat([buffer_1.Buffer.from([0x03]), output.lockupScript.contractId]));
+        const address = utils_1.bs58.encode(buffer_1.Buffer.concat([buffer_1.Buffer.from([0x03]), output.lockupScript.contractId]));
         const tokens = output.tokens.value.map((token) => {
             return {
                 id: token.tokenId.toString('hex'),
@@ -63,7 +63,7 @@ class ContractOutputCodec {
     }
     static convertToOutput(apiContractOutput) {
         const amount = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(apiContractOutput.attoAlphAmount));
-        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(buffer_1.Buffer.from(__1.bs58.decode(apiContractOutput.address)))
+        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(buffer_1.Buffer.from(utils_1.bs58.decode(apiContractOutput.address)))
             .script;
         const tokensValue = apiContractOutput.tokens.map((token) => {
             return {

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

@@ -37,7 +37,7 @@ const publicKeyHashCodec = new PublicKeyHashCodec();
 const publicKeyHashesCodec = new array_codec_1.ArrayCodec(publicKeyHashCodec);
 const multiSigParser = binary_parser_1.Parser.start()
     .nest('publicKeyHashes', { type: publicKeyHashesCodec.parser })
-    .nest('m', { type: compact_int_codec_1.compactUnsignedIntCodec.parser });
+    .nest('m', { type: compact_int_codec_1.compactSignedIntCodec.parser });
 class LockupScriptCodec {
     constructor() {
         this.parser = binary_parser_1.Parser.start()
@@ -59,7 +59,7 @@ class LockupScriptCodec {
         }
         else if (input.scriptType === 1) {
             result.push(...publicKeyHashesCodec.encode(input.script.publicKeyHashes.value));
-            result.push(...compact_int_codec_1.compactUnsignedIntCodec.encode(input.script.m));
+            result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.script.m));
         }
         else if (input.scriptType === 2) {
             result.push(...input.script.scriptHash);

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

@@ -14,7 +14,9 @@ export interface DecodedMethod {
 }
 export interface Method {
     isPublic: boolean;
-    assetModifier: number;
+    usePreapprovedAssets: boolean;
+    useContractAssets: boolean;
+    usePayToContractOnly: boolean;
     argsLength: number;
     localsLength: number;
     returnLength: number;

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

@@ -23,6 +23,31 @@ const binary_parser_1 = require("binary-parser");
 const array_codec_1 = require("./array-codec");
 const compact_int_codec_1 = require("./compact-int-codec");
 const instr_codec_1 = require("./instr-codec");
+function decodeAssetModifier(encoded) {
+    const usePayToContractOnly = (encoded & 4) !== 0;
+    switch (encoded & 3) {
+        case 0:
+            return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: false };
+        case 1:
+            return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: true };
+        case 2:
+            return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: true };
+        case 3:
+            return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: false };
+        default:
+            throw new Error(`Invalid asset modifier: ${encoded}`);
+    }
+}
+function encodeAssetModifier(arg) {
+    const encoded = !arg.usePreapprovedAssets && !arg.useContractAssets
+        ? 0
+        : arg.usePreapprovedAssets && arg.useContractAssets
+            ? 1
+            : !arg.usePreapprovedAssets && arg.useContractAssets
+                ? 2
+                : 3;
+    return encoded | (arg.usePayToContractOnly ? 4 : 0);
+}
 class MethodCodec {
     constructor() {
         this.parser = binary_parser_1.Parser.start()
@@ -55,7 +80,7 @@ class MethodCodec {
     static toMethod(decodedMethod) {
         return {
             isPublic: decodedMethod.isPublic === 1,
-            assetModifier: decodedMethod.assetModifier,
+            ...decodeAssetModifier(decodedMethod.assetModifier),
             argsLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
             localsLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
             returnLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
@@ -65,7 +90,7 @@ class MethodCodec {
     static fromMethod(method) {
         return {
             isPublic: method.isPublic ? 1 : 0,
-            assetModifier: method.assetModifier,
+            assetModifier: encodeAssetModifier(method),
             argsLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.argsLength),
             localsLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.localsLength),
             returnLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.returnLength),

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

@@ -2,15 +2,20 @@ import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { Codec } from './codec';
-import { DecodedMethod } from './method-codec';
+import { DecodedMethod, Method } from './method-codec';
 import { OptionCodec } from './option-codec';
-export interface Script {
+export interface DecodedScript {
     methods: DecodedArray<DecodedMethod>;
 }
-export declare class ScriptCodec implements Codec<Script> {
+export interface Script {
+    methods: Method[];
+}
+export declare class ScriptCodec implements Codec<DecodedScript> {
     parser: Parser;
-    encode(input: Script): Buffer;
-    decode(input: Buffer): Script;
+    encode(input: DecodedScript): Buffer;
+    decode(input: Buffer): DecodedScript;
+    decodeScript(input: Buffer): Script;
+    encodeScript(inputTxScript: Script): Buffer;
 }
 export declare const scriptCodec: ScriptCodec;
-export declare const statefulScriptCodecOpt: OptionCodec<Script>;
+export declare const statefulScriptCodecOpt: OptionCodec<DecodedScript>;

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

@@ -1,6 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.statefulScriptCodecOpt = exports.scriptCodec = exports.ScriptCodec = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,10 +16,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/>.
 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statefulScriptCodecOpt = exports.scriptCodec = exports.ScriptCodec = void 0;
 const buffer_1 = require("buffer/");
 const binary_parser_1 = require("binary-parser");
 const method_codec_1 = require("./method-codec");
 const option_codec_1 = require("./option-codec");
+const compact_int_codec_1 = require("./compact-int-codec");
 class ScriptCodec {
     constructor() {
         this.parser = binary_parser_1.Parser.start().nest('methods', {
@@ -35,6 +36,16 @@ class ScriptCodec {
     decode(input) {
         return this.parser.parse(input);
     }
+    decodeScript(input) {
+        const decodedTxScript = this.decode(input);
+        const methods = decodedTxScript.methods.value.map((decodedMethod) => method_codec_1.MethodCodec.toMethod(decodedMethod));
+        return { methods };
+    }
+    encodeScript(inputTxScript) {
+        const methodLength = compact_int_codec_1.compactUnsignedIntCodec.fromU32(inputTxScript.methods.length);
+        const decodedMethods = inputTxScript.methods.map((method) => method_codec_1.MethodCodec.fromMethod(method));
+        return this.encode({ methods: { value: decodedMethods, length: methodLength } });
+    }
 }
 exports.ScriptCodec = ScriptCodec;
 exports.scriptCodec = new ScriptCodec();

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

@@ -25,7 +25,7 @@ const signature_codec_1 = require("./signature-codec");
 const contract_output_ref_codec_1 = require("./contract-output-ref-codec");
 const asset_output_codec_1 = require("./asset-output-codec");
 const contract_output_codec_1 = require("./contract-output-codec");
-const __1 = require("..");
+const utils_1 = require("../utils");
 const output_codec_1 = require("./output-codec");
 class TransactionCodec {
     constructor() {
@@ -77,7 +77,7 @@ class TransactionCodec {
             const key = contractInput.key.toString('hex');
             return { hint, key };
         });
-        const txIdBytes = (0, __1.hexToBinUnsafe)(txId);
+        const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
         const generatedOutputs = transaction.generatedOutputs.value.map((output, index) => {
             if (output.either === 0) {
                 const fixedAssetOutput = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutput(txIdBytes, output.value, index);

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

@@ -3,7 +3,7 @@ import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { DecodedCompactInt } from './compact-int-codec';
 import { Codec } from './codec';
-import { Script } from './script-codec';
+import { DecodedScript } from './script-codec';
 import { ByteString } from './bytestring-codec';
 import { LockupScript } from './lockup-script-codec';
 export interface P2PKH {
@@ -20,7 +20,7 @@ export interface Val {
     val: number | DecodedCompactInt | ByteString | LockupScript;
 }
 export interface P2SH {
-    script: Script;
+    script: DecodedScript;
     params: DecodedArray<Val>;
 }
 export declare class P2SHCodec implements Codec<P2SH> {

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

@@ -1,7 +1,7 @@
 import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium';
-import { Script } from './script-codec';
+import { DecodedScript } from './script-codec';
 import { Option } from './option-codec';
 import { DecodedCompactInt } from './compact-int-codec';
 import { Input } from './input-codec';
@@ -11,7 +11,7 @@ import { Codec } from './codec';
 export interface UnsignedTx {
     version: number;
     networkId: number;
-    statefulScript: Option<Script>;
+    statefulScript: Option<DecodedScript>;
     gasAmount: DecodedCompactInt;
     gasPrice: DecodedCompactInt;
     inputs: DecodedArray<Input>;

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

@@ -2,10 +2,11 @@ import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
 import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
 import { Optional, HexString } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
+import { Method } from '../codec';
 export type FieldsSig = node.FieldsSig;
 export type MapsSig = node.MapsSig;
 export type EventSig = node.EventSig;
-export type FunctionSig = node.FunctionSig;
+export type FunctionSig = Omit<node.FunctionSig, 'isPublic' | 'usePreapprovedAssets' | 'useAssetsInContract'>;
 export type Fields = NamedVals;
 export type Arguments = NamedVals;
 export type Constant = node.Constant;
@@ -61,7 +62,8 @@ export declare class ProjectArtifact {
     constructor(fullNodeVersion: string, compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
     static isCodeChanged(current: ProjectArtifact, previous: ProjectArtifact): boolean;
     saveToFile(rootPath: string): Promise<void>;
-    needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean;
+    getChangedSources(sourceInfos: SourceInfo[]): SourceInfo[];
+    needToReCompile(compilerOptions: node.CompilerOptions, fullNodeVersion: string): boolean;
     static from(rootPath: string): Promise<ProjectArtifact | undefined>;
 }
 export declare class Struct {
@@ -98,6 +100,7 @@ export declare class Project {
     private static loadStructs;
     private saveStructsToFile;
     private saveArtifactsToFile;
+    private saveProjectArtifact;
     contractByCodeHash(codeHash: string): Contract;
     private static getCompileResult;
     private static compile;
@@ -108,7 +111,7 @@ export declare class Project {
     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): Promise<void>;
+    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;
@@ -116,9 +119,6 @@ export declare abstract class Artifact {
     readonly functions: FunctionSig[];
     constructor(version: string, name: string, functions: FunctionSig[]);
     abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string;
-    publicFunctions(): string[];
-    usingPreapprovedAssetsFunctions(): string[];
-    usingAssetsInContractFunctions(): string[];
     isDevnet(signer: SignerProvider): Promise<boolean>;
 }
 export declare class Contract extends Artifact {
@@ -134,7 +134,11 @@ export declare class Contract extends Artifact {
     readonly stdInterfaceId?: HexString;
     readonly bytecodeDebug: string;
     readonly codeHashDebug: string;
+    readonly decodedMethods: Method[];
     constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], mapsSig?: MapsSig, stdInterfaceId?: HexString);
+    publicFunctions(): FunctionSig[];
+    usingPreapprovedAssetsFunctions(): FunctionSig[];
+    usingAssetsInContractFunctions(): FunctionSig[];
     static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string, structs?: Struct[]): Contract;
     static fromCompileResult(result: node.CompileContractResult, structs?: Struct[]): Contract;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string, structs?: Struct[]): Promise<Contract>;
@@ -323,13 +327,19 @@ export declare function addStdIdToFields<F extends Fields>(contract: Contract, f
 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 class RalphMap<K extends Val, V extends Val> {
     private readonly parentContract;
-    private readonly parentInstance;
+    private readonly parentContractId;
     private readonly mapName;
-    constructor(parentContract: Contract, parentInstance: ContractInstance, mapName: string);
+    private readonly groupIndex;
+    constructor(parentContract: Contract, parentContractId: HexString, mapName: string);
     get(key: K): Promise<V | undefined>;
     contains(key: K): Promise<boolean>;
+    toJSON(): {
+        parentContractId: string;
+        mapName: string;
+        groupIndex: number;
+    };
 }
-export declare function getMapItem<R extends Val>(parentContract: Contract, parentInstance: ContractInstance, mapName: string, key: Val): Promise<R | undefined>;
+export declare function getMapItem<R extends Val>(parentContract: Contract, parentContractId: HexString, groupIndex: number, mapName: string, key: Val): Promise<R | undefined>;
 export declare abstract class ContractInstance {
     readonly address: Address;
     readonly contractId: string;
@@ -347,5 +357,4 @@ export declare function multicallMethods<I extends ContractInstance, F extends F
 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 declare function tryGetCallResult(result: node.CallContractResult): node.CallContractSucceeded;
 export {};