@alephium/web3 1.12.0-beta.0 → 1.12.0-danube.0

package/dist/src/address/address.d.ts

@@ -31,4 +31,5 @@ export declare function groupOfLockupScript(lockupScript: LockupScript): number;
 export declare function groupFromBytes(bytes: Uint8Array): number;
 export declare function groupFromHint(hint: number): number;
 export declare function hasExplicitGroupIndex(address: string): boolean;
+export declare function addressWithoutExplicitGroupIndex(address: string): string;
 export declare function addressFromLockupScript(lockupScript: LockupScript): string;

package/dist/src/address/address.js

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addressFromLockupScript = exports.hasExplicitGroupIndex = exports.groupFromHint = exports.groupFromBytes = exports.groupOfLockupScript = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isContractAddress = exports.defaultGroupOfGrouplessAddress = exports.isGrouplessAddressWithGroupIndex = exports.isGrouplessAddressWithoutGroupIndex = exports.isGrouplessAddress = exports.isAssetAddress = exports.addressToBytes = exports.isValidAddress = exports.validateAddress = exports.AddressType = void 0;
+exports.addressFromLockupScript = exports.addressWithoutExplicitGroupIndex = exports.hasExplicitGroupIndex = exports.groupFromHint = exports.groupFromBytes = exports.groupOfLockupScript = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isContractAddress = exports.defaultGroupOfGrouplessAddress = exports.isGrouplessAddressWithGroupIndex = exports.isGrouplessAddressWithoutGroupIndex = exports.isGrouplessAddress = exports.isAssetAddress = exports.addressToBytes = exports.isValidAddress = exports.validateAddress = exports.AddressType = void 0;
 const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("../constants");
@@ -108,32 +108,27 @@ function decodeAndValidateAddress(address) {
         if (decoded.length === 33)
             return decoded;
     }
-    else if (isGrouplessAddressWithGroup(decoded)) {
-        // [type, keyType, ...publicKey, ...checkSum, ...groupByte]
-        const publicKeyToIndex = decoded.length - 1 - 4;
-        const publicKeyLikeBytes = decoded.slice(1, publicKeyToIndex);
-        const checksum = (0, utils_1.binToHex)(decoded.slice(publicKeyToIndex, publicKeyToIndex + 4));
-        const expectedChecksum = (0, utils_1.binToHex)(codec_1.intAs4BytesCodec.encode((0, djb2_1.default)(publicKeyLikeBytes)));
-        if (checksum !== expectedChecksum) {
-            throw new Error(`Invalid checksum for P2PK address: ${address}`);
+    else if (addressType === AddressType.P2PK) {
+        if (decoded.length === 40) {
+            // [type, keyType, ...publicKey, ...checkSum, ...groupByte]
+            const publicKeyLikeBytes = decoded.slice(1, 35);
+            const checksum = (0, utils_1.binToHex)(decoded.slice(35, 39));
+            const expectedChecksum = (0, utils_1.binToHex)(codec_1.intAs4BytesCodec.encode((0, djb2_1.default)(publicKeyLikeBytes)));
+            if (checksum !== expectedChecksum) {
+                throw new Error(`Invalid checksum for P2PK address: ${address}`);
+            }
+            const group = codec_2.byteCodec.decode(decoded.slice(39, 40));
+            validateGroupIndex(group);
+            return decoded;
         }
-        const group = codec_2.byteCodec.decode(decoded.slice(decoded.length - 1, decoded.length));
-        validateGroupIndex(group);
-        return decoded;
     }
     throw new Error(`Invalid address: ${address}`);
 }
-function isGrouplessAddressWithoutGroup(decoded) {
-    return decoded[0] === AddressType.P2PK && (decoded.length === 38 || decoded.length === 39);
-}
-function isGrouplessAddressWithGroup(decoded) {
-    return decoded[0] === AddressType.P2PK && (decoded.length === 39 || decoded.length === 40);
-}
 function addressToBytes(address) {
     if (hasExplicitGroupIndex(address)) {
         const groupIndex = parseGroupIndex(address[address.length - 1]);
         const decoded = (0, bs58_1.base58ToBytes)(address.slice(0, address.length - 2));
-        if (isGrouplessAddressWithoutGroup(decoded)) {
+        if (decoded[0] === 0x04 && decoded.length === 39) {
             const groupByte = codec_2.byteCodec.encode(groupIndex);
             return new Uint8Array([...decoded, ...groupByte]);
         }
@@ -141,8 +136,8 @@ function addressToBytes(address) {
     }
     else {
         const decoded = (0, bs58_1.base58ToBytes)(address);
-        if (isGrouplessAddressWithoutGroup(decoded)) {
-            const group = defaultGroupOfGrouplessAddress(decoded.slice(2, decoded.length - 4));
+        if (decoded[0] === 0x04 && decoded.length === 39) {
+            const group = defaultGroupOfGrouplessAddress(decoded.slice(2, 35));
             const groupByte = codec_2.byteCodec.encode(group);
             return new Uint8Array([...decoded, ...groupByte]);
         }
@@ -245,7 +240,7 @@ function groupOfPrivateKey(privateKey, keyType) {
 exports.groupOfPrivateKey = groupOfPrivateKey;
 function publicKeyFromPrivateKey(privateKey, _keyType) {
     const keyType = _keyType ?? 'default';
-    if (keyType === 'default' || keyType === 'groupless') {
+    if (keyType === 'default' || keyType === 'gl-secp256k1') {
         const key = ec.keyFromPrivate(privateKey);
         return key.getPublic(true, 'hex');
     }
@@ -261,7 +256,7 @@ function addressFromPublicKey(publicKey, _keyType) {
         const bytes = new Uint8Array([AddressType.P2PKH, ...hash]);
         return bs58_1.default.encode(bytes);
     }
-    else if (keyType === 'groupless') {
+    else if (keyType === 'gl-secp256k1') {
         const publicKeyBytes = new Uint8Array([0x00, ...(0, utils_1.hexToBinUnsafe)(publicKey)]);
         const hashBytes = codec_1.intAs4BytesCodec.encode((0, djb2_1.default)(publicKeyBytes));
         const bytes = new Uint8Array([0x04, ...publicKeyBytes, ...hashBytes]);
@@ -348,6 +343,13 @@ function hasExplicitGroupIndex(address) {
     return address.length > 2 && address[address.length - 2] === ':';
 }
 exports.hasExplicitGroupIndex = hasExplicitGroupIndex;
+function addressWithoutExplicitGroupIndex(address) {
+    if (hasExplicitGroupIndex(address)) {
+        return address.slice(0, address.length - 2);
+    }
+    return address;
+}
+exports.addressWithoutExplicitGroupIndex = addressWithoutExplicitGroupIndex;
 function addressFromLockupScript(lockupScript) {
     if (lockupScript.kind === 'P2PK') {
         const groupByte = lockup_script_codec_1.lockupScriptCodec.encode(lockupScript).slice(-1);

package/dist/src/api/api-alephium.d.ts

@@ -176,7 +176,7 @@ export interface BuildChainedDeployContractTx {
 }
 /** BuildChainedDeployContractTxResult */
 export interface BuildChainedDeployContractTxResult {
-    value: BuildDeployContractTxResult;
+    value: BuildSimpleDeployContractTxResult;
     type: string;
 }
 /** BuildChainedExecuteScriptTx */
@@ -186,7 +186,7 @@ export interface BuildChainedExecuteScriptTx {
 }
 /** BuildChainedExecuteScriptTxResult */
 export interface BuildChainedExecuteScriptTxResult {
-    value: BuildExecuteScriptTxResult;
+    value: BuildSimpleExecuteScriptTxResult;
     type: string;
 }
 /** BuildChainedTransferTx */
@@ -196,7 +196,7 @@ export interface BuildChainedTransferTx {
 }
 /** BuildChainedTransferTxResult */
 export interface BuildChainedTransferTxResult {
-    value: BuildTransferTxResult;
+    value: BuildSimpleTransferTxResult;
     type: string;
 }
 /** BuildChainedTx */
@@ -222,25 +222,13 @@ export interface BuildDeployContractTx {
     gasAmount?: number;
     /** @format uint256 */
     gasPrice?: string;
+    /** @format group-index */
+    group?: number;
     /** @format block-hash */
     targetBlockHash?: string;
 }
 /** BuildDeployContractTxResult */
-export interface BuildDeployContractTxResult {
-    /** @format int32 */
-    fromGroup: number;
-    /** @format int32 */
-    toGroup: number;
-    unsignedTx: string;
-    /** @format gas */
-    gasAmount: number;
-    /** @format uint256 */
-    gasPrice: string;
-    /** @format 32-byte-hash */
-    txId: string;
-    /** @format address */
-    contractAddress: string;
-}
+export type BuildDeployContractTxResult = BuildGrouplessDeployContractTxResult | BuildSimpleDeployContractTxResult;
 /** BuildExecuteScriptTx */
 export interface BuildExecuteScriptTx {
     /** @format hex-string */
@@ -258,74 +246,30 @@ export interface BuildExecuteScriptTx {
     gasPrice?: string;
     /** @format block-hash */
     targetBlockHash?: string;
+    /** @format group-index */
+    group?: number;
     /** @format double */
     gasEstimationMultiplier?: number;
 }
 /** BuildExecuteScriptTxResult */
-export interface BuildExecuteScriptTxResult {
-    /** @format int32 */
-    fromGroup: number;
-    /** @format int32 */
-    toGroup: number;
-    unsignedTx: string;
-    /** @format gas */
-    gasAmount: number;
-    /** @format uint256 */
-    gasPrice: string;
-    /** @format 32-byte-hash */
-    txId: string;
-    simulationResult: SimulationResult;
-}
-/** BuildGrouplessDeployContractTx */
-export interface BuildGrouplessDeployContractTx {
-    fromAddress: string;
-    /** @format hex-string */
-    bytecode: string;
-    /** @format uint256 */
-    initialAttoAlphAmount?: string;
-    initialTokenAmounts?: Token[];
-    /** @format uint256 */
-    issueTokenAmount?: string;
-    /** @format address */
-    issueTokenTo?: string;
-    /** @format uint256 */
-    gasPrice?: string;
-    /** @format block-hash */
-    targetBlockHash?: string;
-}
+export type BuildExecuteScriptTxResult = BuildGrouplessExecuteScriptTxResult | BuildSimpleExecuteScriptTxResult;
 /** BuildGrouplessDeployContractTxResult */
 export interface BuildGrouplessDeployContractTxResult {
-    transferTxs: BuildTransferTxResult[];
-    deployContractTx: BuildDeployContractTxResult;
-}
-/** BuildGrouplessExecuteScriptTx */
-export interface BuildGrouplessExecuteScriptTx {
-    fromAddress: string;
-    /** @format hex-string */
-    bytecode: string;
-    /** @format uint256 */
-    attoAlphAmount?: string;
-    tokens?: Token[];
-    /** @format uint256 */
-    gasPrice?: string;
-    /** @format block-hash */
-    targetBlockHash?: string;
-    /** @format double */
-    gasEstimationMultiplier?: number;
+    transferTxs: BuildSimpleTransferTxResult[];
+    deployContractTx: BuildSimpleDeployContractTxResult;
+    type: string;
 }
 /** BuildGrouplessExecuteScriptTxResult */
 export interface BuildGrouplessExecuteScriptTxResult {
-    transferTxs: BuildTransferTxResult[];
-    executeScriptTx: BuildExecuteScriptTxResult;
+    transferTxs: BuildSimpleTransferTxResult[];
+    executeScriptTx: BuildSimpleExecuteScriptTxResult;
+    type: string;
 }
-/** BuildGrouplessTransferTx */
-export interface BuildGrouplessTransferTx {
-    fromAddress: string;
-    destinations: Destination[];
-    /** @format uint256 */
-    gasPrice?: string;
-    /** @format block-hash */
-    targetBlockHash?: string;
+/** BuildGrouplessTransferTxResult */
+export interface BuildGrouplessTransferTxResult {
+    transferTxs: BuildSimpleTransferTxResult[];
+    transferTx: BuildSimpleTransferTxResult;
+    type: string;
 }
 /** BuildInfo */
 export interface BuildInfo {
@@ -362,6 +306,54 @@ export interface BuildMultisigAddressResult {
     /** @format address */
     address: string;
 }
+/** BuildSimpleDeployContractTxResult */
+export interface BuildSimpleDeployContractTxResult {
+    /** @format int32 */
+    fromGroup: number;
+    /** @format int32 */
+    toGroup: number;
+    unsignedTx: string;
+    /** @format gas */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    /** @format 32-byte-hash */
+    txId: string;
+    /** @format address */
+    contractAddress: string;
+    type: string;
+}
+/** BuildSimpleExecuteScriptTxResult */
+export interface BuildSimpleExecuteScriptTxResult {
+    /** @format int32 */
+    fromGroup: number;
+    /** @format int32 */
+    toGroup: number;
+    unsignedTx: string;
+    /** @format gas */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    /** @format 32-byte-hash */
+    txId: string;
+    simulationResult: SimulationResult;
+    type: string;
+}
+/** BuildSimpleTransferTxResult */
+export interface BuildSimpleTransferTxResult {
+    unsignedTx: string;
+    /** @format gas */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    /** @format 32-byte-hash */
+    txId: string;
+    /** @format int32 */
+    fromGroup: number;
+    /** @format int32 */
+    toGroup: number;
+    type: string;
+}
 /** BuildSweepAddressTransactions */
 export interface BuildSweepAddressTransactions {
     /** @format public-key */
@@ -421,23 +413,13 @@ export interface BuildTransferTx {
     gasAmount?: number;
     /** @format uint256 */
     gasPrice?: string;
+    /** @format group-index */
+    group?: number;
     /** @format block-hash */
     targetBlockHash?: string;
 }
 /** BuildTransferTxResult */
-export interface BuildTransferTxResult {
-    unsignedTx: string;
-    /** @format gas */
-    gasAmount: number;
-    /** @format uint256 */
-    gasPrice: string;
-    /** @format 32-byte-hash */
-    txId: string;
-    /** @format int32 */
-    fromGroup: number;
-    /** @format int32 */
-    toGroup: number;
-}
+export type BuildTransferTxResult = BuildGrouplessTransferTxResult | BuildSimpleTransferTxResult;
 /** CallContract */
 export interface CallContract {
     /** @format int32 */
@@ -1133,6 +1115,7 @@ export interface TestContract {
     args?: Val[];
     existingContracts?: ContractState[];
     inputAssets?: TestInputAsset[];
+    dustAmount?: string;
 }
 /** TestContractResult */
 export interface TestContractResult {
@@ -1909,7 +1892,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned transfer transaction to a number of recipients
          * @request POST:/transactions/build
          */
-        postTransactionsBuild: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildTransferTxResult>;
+        postTransactionsBuild: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildSimpleTransferTxResult | BuildGrouplessTransferTxResult>;
         /**
          * No description
          *
@@ -1918,7 +1901,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build unsigned transfer transactions from an address of one group to addresses of many groups. Each target group requires a dedicated transaction or more in case large number of outputs needed to be split.
          * @request POST:/transactions/build-transfer-from-one-to-many-groups
          */
-        postTransactionsBuildTransferFromOneToManyGroups: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildTransferTxResult[]>;
+        postTransactionsBuildTransferFromOneToManyGroups: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildSimpleTransferTxResult[]>;
         /**
          * No description
          *
@@ -1927,7 +1910,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned transaction with multiple addresses to a number of recipients
          * @request POST:/transactions/build-multi-addresses
          */
-        postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params?: RequestParams) => Promise<BuildTransferTxResult>;
+        postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params?: RequestParams) => Promise<BuildSimpleTransferTxResult>;
         /**
          * No description
          *
@@ -2096,7 +2079,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned script
          * @request POST:/contracts/unsigned-tx/execute-script
          */
-        postContractsUnsignedTxExecuteScript: (data: BuildExecuteScriptTx, params?: RequestParams) => Promise<BuildExecuteScriptTxResult>;
+        postContractsUnsignedTxExecuteScript: (data: BuildExecuteScriptTx, params?: RequestParams) => Promise<BuildSimpleExecuteScriptTxResult | BuildGrouplessExecuteScriptTxResult>;
         /**
          * No description
          *
@@ -2123,7 +2106,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned contract
          * @request POST:/contracts/unsigned-tx/deploy-contract
          */
-        postContractsUnsignedTxDeployContract: (data: BuildDeployContractTx, params?: RequestParams) => Promise<BuildDeployContractTxResult>;
+        postContractsUnsignedTxDeployContract: (data: BuildDeployContractTx, params?: RequestParams) => Promise<BuildSimpleDeployContractTxResult | BuildGrouplessDeployContractTxResult>;
         /**
          * No description
          *
@@ -2229,7 +2212,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build a multisig unsigned transaction
          * @request POST:/multisig/build
          */
-        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildTransferTxResult>;
+        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildSimpleTransferTxResult>;
         /**
          * No description
          *
@@ -2374,34 +2357,5 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          */
         putUtilsCheckHashIndexing: (params?: RequestParams) => Promise<void>;
     };
-    groupless: {
-        /**
-         * No description
-         *
-         * @tags Groupless
-         * @name PostGrouplessTransfer
-         * @summary Build unsigned transfer transactions from a groupless address
-         * @request POST:/groupless/transfer
-         */
-        postGrouplessTransfer: (data: BuildGrouplessTransferTx, params?: RequestParams) => Promise<BuildTransferTxResult[]>;
-        /**
-         * No description
-         *
-         * @tags Groupless
-         * @name PostGrouplessExecuteScript
-         * @summary Build an unsigned execute script transaction from a groupless address
-         * @request POST:/groupless/execute-script
-         */
-        postGrouplessExecuteScript: (data: BuildGrouplessExecuteScriptTx, params?: RequestParams) => Promise<BuildGrouplessExecuteScriptTxResult>;
-        /**
-         * No description
-         *
-         * @tags Groupless
-         * @name PostGrouplessDeployContract
-         * @summary Build an unsigned deploy contract transaction from a groupless address
-         * @request POST:/groupless/deploy-contract
-         */
-        postGrouplessDeployContract: (data: BuildGrouplessDeployContractTx, params?: RequestParams) => Promise<BuildGrouplessDeployContractTxResult>;
-    };
 }
 export {};

package/dist/src/api/api-alephium.js

@@ -1547,56 +1547,6 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
-        this.groupless = {
-            /**
-             * No description
-             *
-             * @tags Groupless
-             * @name PostGrouplessTransfer
-             * @summary Build unsigned transfer transactions from a groupless address
-             * @request POST:/groupless/transfer
-             */
-            postGrouplessTransfer: (data, params = {}) => this.request({
-                path: `/groupless/transfer`,
-                method: 'POST',
-                body: data,
-                type: ContentType.Json,
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse),
-            /**
-             * No description
-             *
-             * @tags Groupless
-             * @name PostGrouplessExecuteScript
-             * @summary Build an unsigned execute script transaction from a groupless address
-             * @request POST:/groupless/execute-script
-             */
-            postGrouplessExecuteScript: (data, params = {}) => this.request({
-                path: `/groupless/execute-script`,
-                method: 'POST',
-                body: data,
-                type: ContentType.Json,
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse),
-            /**
-             * No description
-             *
-             * @tags Groupless
-             * @name PostGrouplessDeployContract
-             * @summary Build an unsigned deploy contract transaction from a groupless address
-             * @request POST:/groupless/deploy-contract
-             */
-            postGrouplessDeployContract: (data, params = {}) => this.request({
-                path: `/groupless/deploy-contract`,
-                method: 'POST',
-                body: data,
-                type: ContentType.Json,
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse)
-        };
     }
 }
 exports.Api = Api;

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

@@ -14,7 +14,6 @@ interface NodeProviderApis {
     utils: NodeApi<string>['utils'];
     miners: NodeApi<string>['miners'];
     events: NodeApi<string>['events'];
-    groupless: NodeApi<string>['groupless'];
 }
 export declare class NodeProvider implements NodeProviderApis {
     readonly wallets: NodeApi<string>['wallets'];
@@ -28,7 +27,6 @@ export declare class NodeProvider implements NodeProviderApis {
     readonly utils: NodeApi<string>['utils'];
     readonly miners: NodeApi<string>['miners'];
     readonly events: NodeApi<string>['events'];
-    readonly groupless: NodeApi<string>['groupless'];
     constructor(baseUrl: string, apiKey?: string, customFetch?: typeof fetch);
     constructor(provider: NodeProvider);
     constructor(handler: ApiRequestHandler);

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

@@ -185,7 +185,6 @@ class NodeProvider {
         this.utils = { ...nodeApi.utils };
         this.miners = { ...nodeApi.miners };
         this.events = { ...nodeApi.events };
-        this.groupless = { ...nodeApi.groupless };
         (0, types_1.requestWithLog)(this);
     }
     // This can prevent the proxied node provider from being modified

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

@@ -3,6 +3,7 @@ import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScri
 import { Optional, HexString } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
 import { contract, Method } from '../codec';
+import { SimulationResult } from '../api/api-alephium';
 export type FieldsSig = node.FieldsSig;
 export type MapsSig = node.MapsSig;
 export type EventSig = node.EventSig;
@@ -100,7 +101,7 @@ export declare class Script extends Artifact {
     static fromJson(artifact: any, bytecodeDebugPatch?: string, structs?: Struct[]): Script;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string, structs?: Struct[]): Promise<Script>;
     toString(): string;
-    txParamsForExecution<P extends Fields>(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<SignExecuteScriptTxParams>;
+    txParamsForExecution<P extends Fields>(params: ExecuteScriptParams<P>): Promise<SignExecuteScriptTxParams>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
 export declare function fromApiFields(immFields: node.Val[], mutFields: node.Val[], fieldsSig: FieldsSig, structs: Struct[]): NamedVals;
@@ -131,7 +132,7 @@ export interface ContractStateWithMaps<T extends Fields = Fields, M extends Reco
 export type TestContractParamsWithoutMaps<F extends Fields = Fields, A extends Arguments = Arguments> = Omit<TestContractParams<F, A>, 'initialMaps'>;
 export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>> {
     group?: number;
-    address?: string;
+    contractAddress?: string;
     callerContractAddress?: string;
     blockHash?: string;
     blockTimeStamp?: number;
@@ -139,9 +140,10 @@ export interface TestContractParams<F extends Fields = Fields, A extends Argumen
     initialFields: F;
     initialMaps?: M;
     initialAsset?: Asset;
-    testArgs: A;
+    args: A;
     existingContracts?: ContractStateWithMaps[];
     inputAssets?: InputAsset[];
+    dustAmount?: Number256;
 }
 export interface ContractEvent<T extends Fields = Fields> {
     txId: string;
@@ -187,6 +189,7 @@ export interface DeployContractParams<P extends Fields = Fields> {
     gasAmount?: number;
     gasPrice?: Number256;
     exposePrivateFunctions?: boolean;
+    group?: number;
 }
 export type DeployContractResult<T extends ContractInstance> = Omit<SignDeployContractTxResult, 'contractId' | 'contractAddress' | 'groupIndex'> & {
     contractInstance: T;
@@ -203,11 +206,12 @@ export declare class ExecutableScript<P extends Fields = Fields, R extends Val |
     readonly script: Script;
     readonly getContractByCodeHash: (codeHash: string) => Contract;
     constructor(script: Script, getContractByCodeHash: (codeHash: string) => Contract);
-    execute(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<ExecuteScriptResult>;
+    execute(params: ExecuteScriptParams<P>): Promise<ExecuteScriptResult>;
     call(params: CallScriptParams<P>): Promise<CallScriptResult<R>>;
 }
 export interface ExecuteScriptParams<P extends Fields = Fields> {
     initialFields: P;
+    signer: SignerProvider;
     attoAlphAmount?: Number256;
     tokens?: Token[];
     gasAmount?: number;
@@ -220,6 +224,7 @@ export interface ExecuteScriptResult {
     signature: string;
     gasAmount: number;
     gasPrice: Number256;
+    simulationResult: SimulationResult;
 }
 export interface CallScriptParams<P extends Fields = Fields> {
     initialFields: P;
@@ -273,11 +278,11 @@ 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 extractMapsFromApiResult(selfAddress: string, params: Optional<TestContractParams, 'testArgs' | 'initialFields'>, group: number, apiResult: node.TestContractResult, getContractByCodeHash: (codeHash: string) => Contract): {
+export declare function extractMapsFromApiResult(selfAddress: string, params: Optional<TestContractParams, 'args' | 'initialFields'>, group: number, apiResult: node.TestContractResult, getContractByCodeHash: (codeHash: string) => Contract): {
     address: string;
     maps: Record<string, Map<Val, Val>>;
 }[];
-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 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>, 'args' | 'initialFields'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<TestContractResult<R, M>>;
 export declare function getDebugMessagesFromTx(txId: HexString, provider?: NodeProvider): Promise<{
     contractAddress: string;
     message: string;