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

package/dist/src/contract/contract.js

@@ -309,16 +309,17 @@ class Contract extends Artifact {
             blockHash: params.blockHash,
             blockTimeStamp: params.blockTimeStamp,
             txId: params.txId,
-            address: params.address,
+            address: params.contractAddress,
             callerContractAddress: params.callerContractAddress,
             bytecode: this.isInlineFunc(methodIndex) ? this.getByteCodeForTesting() : this.bytecodeDebug,
             initialImmFields: immFields,
             initialMutFields: mutFields,
             initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
             methodIndex,
-            args: this.toApiArgs(funcName, params.testArgs),
+            args: this.toApiArgs(funcName, params.args),
             existingContracts: this.toApiContractStates(params.existingContracts),
-            inputAssets: toApiInputAssets(params.inputAssets)
+            inputAssets: toApiInputAssets(params.inputAssets),
+            dustAmount: params.dustAmount?.toString()
         };
     }
     fromApiContractState(state) {
@@ -387,15 +388,13 @@ class Contract extends Artifact {
         const initialFields = params.initialFields ?? {};
         const bytecode = this.buildByteCodeToDeploy(addStdIdToFields(this, initialFields), isDevnet, params.exposePrivateFunctions ?? false);
         const selectedAccount = await signer.getSelectedAccount();
-        let signerAddress = selectedAccount.address;
-        if ((0, address_1.isGrouplessAddressWithoutGroupIndex)(selectedAccount.address)) {
+        if (selectedAccount.keyType === 'gl-secp256k1') {
             if (group === undefined) {
                 throw new Error('Groupless address requires explicit group number for contract deployment');
             }
-            signerAddress = `${selectedAccount.address}:${group}`;
         }
         const signerParams = {
-            signerAddress,
+            signerAddress: selectedAccount.address,
             signerKeyType: selectedAccount.keyType,
             bytecode: bytecode,
             initialAttoAlphAmount: params?.initialAttoAlphAmount,
@@ -403,7 +402,8 @@ class Contract extends Artifact {
             issueTokenTo: params?.issueTokenTo,
             initialTokenAmounts: params?.initialTokenAmounts,
             gasAmount: params?.gasAmount,
-            gasPrice: params?.gasPrice
+            gasPrice: params?.gasPrice,
+            group: group
         };
         return signerParams;
     }
@@ -519,8 +519,8 @@ class Script extends Artifact {
         };
         return JSON.stringify(object, null, 2);
     }
-    async txParamsForExecution(signer, params) {
-        const selectedAccount = await signer.getSelectedAccount();
+    async txParamsForExecution(params) {
+        const selectedAccount = await params.signer.getSelectedAccount();
         const signerParams = {
             signerAddress: selectedAccount.address,
             signerKeyType: selectedAccount.keyType,
@@ -691,10 +691,18 @@ class ContractFactory {
             initialFields: addStdIdToFields(this.contract, deployParams.initialFields)
         }, group);
         const result = await signer.signAndSubmitDeployContractTx(signerParams);
-        return {
-            ...result,
-            contractInstance: this.at(result.contractAddress)
-        };
+        if ('transferTxs' in result) {
+            return {
+                ...result.tx,
+                contractInstance: this.at(result.tx.contractAddress)
+            };
+        }
+        else {
+            return {
+                ...result,
+                contractInstance: this.at(result.contractAddress)
+            };
+        }
     }
     async deployTemplate(signer) {
         return this.deploy(signer, {
@@ -722,9 +730,15 @@ class ExecutableScript {
         this.script = script;
         this.getContractByCodeHash = getContractByCodeHash;
     }
-    async execute(signer, params) {
-        const signerParams = await this.script.txParamsForExecution(signer, params);
-        return await signer.signAndSubmitExecuteScriptTx(signerParams);
+    async execute(params) {
+        const signerParams = await this.script.txParamsForExecution(params);
+        const result = await params.signer.signAndSubmitExecuteScriptTx(signerParams);
+        if ('transferTxs' in result) {
+            return result.tx;
+        }
+        else {
+            return result;
+        }
     }
     async call(params) {
         const mainFunc = this.script.functions.find((f) => f.name === 'main');
@@ -971,16 +985,16 @@ exports.extractMapsFromApiResult = extractMapsFromApiResult;
 async function testMethod(factory, methodName, params, getContractByCodeHash) {
     const txId = params?.txId ?? randomTxId();
     const selfContract = factory.contract;
-    const selfAddress = params.address ?? (0, address_1.addressFromContractId)((0, utils_1.binToHex)(crypto.getRandomValues(new Uint8Array(32))));
+    const selfAddress = params.contractAddress ?? (0, address_1.addressFromContractId)((0, utils_1.binToHex)(crypto.getRandomValues(new Uint8Array(32))));
     const selfContractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(selfAddress));
     const group = params.group ?? 0;
     const existingContracts = getTestExistingContracts(selfContract, selfContractId, group, params, getContractByCodeHash);
     const apiParams = selfContract.toApiTestContractParams(methodName, {
         ...params,
-        address: selfAddress,
+        contractAddress: selfAddress,
         txId: txId,
         initialFields: addStdIdToFields(selfContract, params.initialFields ?? {}),
-        testArgs: params.testArgs === undefined ? {} : params.testArgs,
+        args: params.args === undefined ? {} : params.args,
         existingContracts
     });
     const apiResult = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsTestContract(apiParams);
@@ -1258,7 +1272,7 @@ async function signExecuteMethod(contract, instance, methodName, params) {
         gasAmount: params.gasAmount,
         gasPrice: params.gasPrice
     };
-    const result = await signer.signAndSubmitExecuteScriptTx(signerParams);
+    const result = (await signer.signAndSubmitExecuteScriptTx(signerParams));
     if ((0, debug_1.isContractDebugMessageEnabled)() && isDevnet) {
         await printDebugMessagesFromTx(result.txId, signer.nodeProvider);
     }

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

@@ -1,3 +1,4 @@
+import { SimulationResult } from '../api/api-alephium';
 import { ContractInstance } from './contract';
 export interface ExecutionResult {
     txId: string;
@@ -16,4 +17,5 @@ export interface DeployContractExecutionResult<I extends ContractInstance = Cont
 }
 export interface RunScriptResult extends ExecutionResult {
     groupIndex: number;
+    simulationResult: SimulationResult;
 }

package/dist/src/signer/signer.d.ts

@@ -1,15 +1,15 @@
 import { ExplorerProvider, NodeProvider } from '../api';
 import { node } from '../api';
-import { Account, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, KeyType, MessageHasher, SignChainedTxParams, SignChainedTxResult } from './types';
+import { Account, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, KeyType, MessageHasher, SignChainedTxParams, SignChainedTxResult, BuildTxResult, SignTxResult } from './types';
 export declare abstract class SignerProvider {
     abstract get nodeProvider(): NodeProvider | undefined;
     abstract get explorerProvider(): ExplorerProvider | undefined;
     protected abstract unsafeGetSelectedAccount(): Promise<Account>;
     getSelectedAccount(): Promise<Account>;
     static validateAccount(account: Account): void;
-    abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTxResult<SignTransferTxResult>>;
+    abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignTxResult<SignDeployContractTxResult>>;
+    abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignTxResult<SignExecuteScriptTxResult>>;
     abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
     abstract signAndSubmitChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>;
     abstract signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
@@ -23,18 +23,18 @@ export declare abstract class InteractiveSignerProvider<EnableOptions extends En
 export declare abstract class SignerProviderSimple extends SignerProvider {
     abstract get nodeProvider(): NodeProvider;
     submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult>;
-    signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTxResult<SignTransferTxResult>>;
+    signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignTxResult<SignDeployContractTxResult>>;
+    signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignTxResult<SignExecuteScriptTxResult>>;
     signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
     signAndSubmitChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>;
     protected abstract getPublicKey(address: string): Promise<string>;
-    signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>>;
-    signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    buildDeployContractTx(params: SignDeployContractTxParams): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
-    signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
-    buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>>;
+    signTransferTx(params: SignTransferTxParams): Promise<SignTxResult<SignTransferTxResult>>;
+    buildTransferTx(params: SignTransferTxParams): Promise<BuildTxResult<SignTransferTxResult>>;
+    signDeployContractTx(params: SignDeployContractTxParams): Promise<SignTxResult<SignDeployContractTxResult>>;
+    buildDeployContractTx(params: SignDeployContractTxParams): Promise<BuildTxResult<SignDeployContractTxResult>>;
+    signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignTxResult<SignExecuteScriptTxResult>>;
+    buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<BuildTxResult<SignExecuteScriptTxResult>>;
     signChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>;
     buildChainedTx(params: SignChainedTxParams[]): Promise<Omit<SignChainedTxResult, 'signature'>[]>;
     signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;

package/dist/src/signer/signer.js

@@ -81,17 +81,41 @@ class SignerProviderSimple extends SignerProvider {
     }
     async signAndSubmitTransferTx(params) {
         const signResult = await this.signTransferTx(params);
-        await this.submitTransaction(signResult);
+        if ('transferTxs' in signResult) {
+            for (const r of signResult.transferTxs) {
+                await this.submitTransaction(r);
+            }
+            await this.submitTransaction(signResult.tx);
+        }
+        else {
+            await this.submitTransaction(signResult);
+        }
         return signResult;
     }
     async signAndSubmitDeployContractTx(params) {
         const signResult = await this.signDeployContractTx(params);
-        await this.submitTransaction(signResult);
+        if ('transferTxs' in signResult) {
+            for (const r of signResult.transferTxs) {
+                await this.submitTransaction(r);
+            }
+            await this.submitTransaction(signResult.tx);
+        }
+        else {
+            await this.submitTransaction(signResult);
+        }
         return signResult;
     }
     async signAndSubmitExecuteScriptTx(params) {
         const signResult = await this.signExecuteScriptTx(params);
-        await this.submitTransaction(signResult);
+        if ('transferTxs' in signResult) {
+            for (const r of signResult.transferTxs) {
+                await this.submitTransaction(r);
+            }
+            await this.submitTransaction(signResult.tx);
+        }
+        else {
+            await this.submitTransaction(signResult);
+        }
         return signResult;
     }
     async signAndSubmitUnsignedTx(params) {
@@ -108,24 +132,75 @@ class SignerProviderSimple extends SignerProvider {
     }
     async signTransferTx(params) {
         const response = await this.buildTransferTx(params);
-        const signature = await this.signRaw(params.signerAddress, response.txId);
-        return { signature, ...response };
+        if ('transferTxs' in response) {
+            const transferTxs = [];
+            for (let i = 0; i < response.transferTxs.length; i++) {
+                const txSignature = await this.signRaw(params.signerAddress, response.transferTxs[i].txId);
+                transferTxs.push({
+                    ...response.transferTxs[i],
+                    signature: txSignature
+                });
+            }
+            const signature = await this.signRaw(params.signerAddress, response.tx.txId);
+            return {
+                transferTxs,
+                tx: { ...response.tx, signature }
+            };
+        }
+        else {
+            const signature = await this.signRaw(params.signerAddress, response.txId);
+            return { signature, ...response };
+        }
     }
     async buildTransferTx(params) {
         return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildTransferTx(params, await this.getPublicKey(params.signerAddress));
     }
     async signDeployContractTx(params) {
         const response = await this.buildDeployContractTx(params);
-        const signature = await this.signRaw(params.signerAddress, response.txId);
-        return { signature, ...response };
+        if ('transferTxs' in response) {
+            const transferTxs = [];
+            for (let i = 0; i < response.transferTxs.length; i++) {
+                const txSignature = await this.signRaw(params.signerAddress, response.transferTxs[i].txId);
+                transferTxs.push({
+                    ...response.transferTxs[i],
+                    signature: txSignature
+                });
+            }
+            const signature = await this.signRaw(params.signerAddress, response.tx.txId);
+            return {
+                transferTxs,
+                tx: { ...response.tx, signature }
+            };
+        }
+        else {
+            const signature = await this.signRaw(params.signerAddress, response.txId);
+            return { signature, ...response };
+        }
     }
     async buildDeployContractTx(params) {
         return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildDeployContractTx(params, await this.getPublicKey(params.signerAddress));
     }
     async signExecuteScriptTx(params) {
         const response = await this.buildExecuteScriptTx(params);
-        const signature = await this.signRaw(params.signerAddress, response.txId);
-        return { signature, ...response };
+        if ('transferTxs' in response) {
+            const transferTxs = [];
+            for (let i = 0; i < response.transferTxs.length; i++) {
+                const txSignature = await this.signRaw(params.signerAddress, response.transferTxs[i].txId);
+                transferTxs.push({
+                    ...response.transferTxs[i],
+                    signature: txSignature
+                });
+            }
+            const signature = await this.signRaw(params.signerAddress, response.tx.txId);
+            return {
+                transferTxs,
+                tx: { ...response.tx, signature }
+            };
+        }
+        else {
+            const signature = await this.signRaw(params.signerAddress, response.txId);
+            return { signature, ...response };
+        }
     }
     async buildExecuteScriptTx(params) {
         return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress));

package/dist/src/signer/tx-builder.d.ts

@@ -1,22 +1,16 @@
 import { NodeProvider } from '../api';
-import { SignChainedTxParams, SignChainedTxResult, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SignGrouplessTransferTxParams, SignGrouplessDeployContractTxParams, SignGrouplessExecuteScriptTxParams } from './types';
+import { SignChainedTxParams, SignChainedTxResult, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, BuildTxResult } from './types';
 export declare abstract class TransactionBuilder {
     abstract get nodeProvider(): NodeProvider;
     static from(nodeProvider: NodeProvider): TransactionBuilder;
     static from(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): TransactionBuilder;
     private static validatePublicKey;
-    buildTransferTx(params: SignTransferTxParams, publicKey: string): Promise<Omit<SignTransferTxResult, 'signature'>>;
-    buildDeployContractTx(params: SignDeployContractTxParams, publicKey: string): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
-    buildExecuteScriptTx(params: SignExecuteScriptTxParams, publicKey: string): Promise<Omit<SignExecuteScriptTxResult, 'signature'>>;
+    buildTransferTx(params: SignTransferTxParams, publicKey: string): Promise<BuildTxResult<SignTransferTxResult>>;
+    buildDeployContractTx(params: SignDeployContractTxParams, publicKey: string): Promise<BuildTxResult<SignDeployContractTxResult>>;
+    buildExecuteScriptTx(params: SignExecuteScriptTxParams, publicKey: string): Promise<BuildTxResult<SignExecuteScriptTxResult>>;
     buildChainedTx(params: SignChainedTxParams[], publicKeys: string[]): Promise<Omit<SignChainedTxResult, 'signature'>[]>;
-    buildGrouplessTransferTx(params: SignGrouplessTransferTxParams): Promise<Omit<SignChainedTxResult, 'signature'>[]>;
-    buildGrouplessDeployContractTx(params: SignGrouplessDeployContractTxParams): Promise<Omit<SignChainedTxResult, 'signature'>[]>;
-    buildGrouplessExecuteScriptTx(params: SignGrouplessExecuteScriptTxParams): Promise<Omit<SignChainedTxResult, 'signature'>[]>;
     static buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'>;
     private buildTransferTxParams;
-    private buildGrouplessTransferTxParams;
-    private buildGrouplessDeployContractTxParams;
-    private buildGrouplessExecuteScriptTxParams;
     private buildDeployContractTxParams;
     private buildExecuteScriptTxParams;
     private convertTransferTxResult;

package/dist/src/signer/tx-builder.js

@@ -109,42 +109,6 @@ class TransactionBuilder {
         });
         return results;
     }
-    async buildGrouplessTransferTx(params) {
-        const data = this.buildGrouplessTransferTxParams(params);
-        const response = await this.nodeProvider.groupless.postGrouplessTransfer(data);
-        return response.map((result) => {
-            return {
-                ...this.convertTransferTxResult(result),
-                type: 'Transfer'
-            };
-        });
-    }
-    async buildGrouplessDeployContractTx(params) {
-        const data = this.buildGrouplessDeployContractTxParams(params);
-        const response = await this.nodeProvider.groupless.postGrouplessDeployContract(data);
-        const transferTxs = response.transferTxs.map((result) => ({
-            ...this.convertTransferTxResult(result),
-            type: 'Transfer'
-        }));
-        const deployContractTx = {
-            ...this.convertDeployContractTxResult(response.deployContractTx),
-            type: 'DeployContract'
-        };
-        return [...transferTxs, deployContractTx];
-    }
-    async buildGrouplessExecuteScriptTx(params) {
-        const data = this.buildGrouplessExecuteScriptTxParams(params);
-        const response = await this.nodeProvider.groupless.postGrouplessExecuteScript(data);
-        const transferTxs = response.transferTxs.map((result) => ({
-            ...this.convertTransferTxResult(result),
-            type: 'Transfer'
-        }));
-        const executeScriptTx = {
-            ...this.convertExecuteScriptTxResult(response.executeScriptTx),
-            type: 'ExecuteScript'
-        };
-        return [...transferTxs, executeScriptTx];
-    }
     static buildUnsignedTx(params) {
         const unsignedTxBin = (0, utils_1.hexToBinUnsafe)(params.unsignedTx);
         const decoded = codec_1.unsignedTxCodec.decode(unsignedTxBin);
@@ -170,37 +134,6 @@ class TransactionBuilder {
             ...rest
         };
     }
-    buildGrouplessTransferTxParams(params) {
-        return {
-            fromAddress: params.fromAddress,
-            destinations: (0, signer_1.toApiDestinations)(params.destinations),
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice),
-            targetBlockHash: params.targetBlockHash
-        };
-    }
-    buildGrouplessDeployContractTxParams(params) {
-        return {
-            fromAddress: params.fromAddress,
-            bytecode: params.bytecode,
-            initialAttoAlphAmount: (0, api_1.toApiNumber256Optional)(params.initialAttoAlphAmount),
-            initialTokenAmounts: (0, api_1.toApiTokens)(params.initialTokenAmounts),
-            issueTokenAmount: (0, api_1.toApiNumber256Optional)(params.issueTokenAmount),
-            issueTokenTo: params.issueTokenTo,
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice),
-            targetBlockHash: params.targetBlockHash
-        };
-    }
-    buildGrouplessExecuteScriptTxParams(params) {
-        return {
-            fromAddress: params.fromAddress,
-            bytecode: params.bytecode,
-            attoAlphAmount: (0, api_1.toApiNumber256Optional)(params.attoAlphAmount),
-            tokens: (0, api_1.toApiTokens)(params.tokens),
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice),
-            targetBlockHash: params.targetBlockHash,
-            gasEstimationMultiplier: params.gasEstimationMultiplier
-        };
-    }
     buildDeployContractTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params;
@@ -227,12 +160,40 @@ class TransactionBuilder {
         };
     }
     convertTransferTxResult(result) {
+        // BuildGrouplessTransferTxResult
+        if ('transferTxs' in result) {
+            return {
+                transferTxs: result.transferTxs.map((r) => ({
+                    ...r,
+                    gasPrice: (0, api_1.fromApiNumber256)(r.gasPrice)
+                })),
+                tx: {
+                    ...result.transferTx,
+                    gasPrice: (0, api_1.fromApiNumber256)(result.transferTx.gasPrice)
+                }
+            };
+        }
         return {
             ...result,
             gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
         };
     }
     convertDeployContractTxResult(result) {
+        if ('transferTxs' in result) {
+            const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(result.deployContractTx.contractAddress));
+            return {
+                transferTxs: result.transferTxs.map((r) => ({
+                    ...r,
+                    gasPrice: (0, api_1.fromApiNumber256)(r.gasPrice)
+                })),
+                tx: {
+                    ...result.deployContractTx,
+                    groupIndex: result.deployContractTx.fromGroup,
+                    contractId,
+                    gasPrice: (0, api_1.fromApiNumber256)(result.deployContractTx.gasPrice)
+                }
+            };
+        }
         const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(result.contractAddress));
         return {
             ...result,
@@ -242,6 +203,19 @@ class TransactionBuilder {
         };
     }
     convertExecuteScriptTxResult(result) {
+        if ('transferTxs' in result) {
+            return {
+                transferTxs: result.transferTxs.map((r) => ({
+                    ...r,
+                    gasPrice: (0, api_1.fromApiNumber256)(r.gasPrice)
+                })),
+                tx: {
+                    ...result.executeScriptTx,
+                    groupIndex: result.executeScriptTx.fromGroup,
+                    gasPrice: (0, api_1.fromApiNumber256)(result.executeScriptTx.gasPrice)
+                }
+            };
+        }
         return {
             ...result,
             groupIndex: result.fromGroup,

package/dist/src/signer/types.d.ts

@@ -11,7 +11,7 @@ export interface Destination {
     lockTime?: number;
     message?: string;
 }
-export type KeyType = 'default' | 'bip340-schnorr' | 'groupless';
+export type KeyType = 'default' | 'bip340-schnorr' | 'gl-secp256k1';
 export interface Account {
     keyType: KeyType;
     address: string;
@@ -29,6 +29,7 @@ export interface SignTransferTxParams {
     utxos?: OutputRef[];
     gasAmount?: number;
     gasPrice?: Number256;
+    group?: number;
 }
 export interface SignTransferTxResult {
     fromGroup: number;
@@ -49,6 +50,7 @@ export interface SignDeployContractTxParams {
     issueTokenTo?: string;
     gasAmount?: number;
     gasPrice?: Number256;
+    group?: number;
 }
 export interface SignDeployContractTxResult {
     groupIndex: number;
@@ -69,6 +71,7 @@ export interface SignExecuteScriptTxParams {
     gasAmount?: number;
     gasPrice?: Number256;
     gasEstimationMultiplier?: number;
+    group?: number;
 }
 export interface SignExecuteScriptTxResult {
     groupIndex: number;
@@ -79,6 +82,16 @@ export interface SignExecuteScriptTxResult {
     gasPrice: Number256;
     simulationResult: SimulationResult;
 }
+export interface GrouplessBuildTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> {
+    transferTxs: Omit<SignTransferTxResult, 'signature'>[];
+    tx: Omit<T, 'signature'>;
+}
+export type BuildTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> = GrouplessBuildTxResult<T> | Omit<T, 'signature'>;
+export interface GrouplessSignTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> {
+    transferTxs: SignTransferTxResult[];
+    tx: T;
+}
+export type SignTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> = GrouplessSignTxResult<T> | T;
 export interface SignUnsignedTxParams {
     signerAddress: string;
     signerKeyType?: KeyType;
@@ -113,32 +126,6 @@ export type SignExecuteScriptChainedTxResult = SignExecuteScriptTxResult & {
     type: 'ExecuteScript';
 };
 export type SignChainedTxResult = SignTransferChainedTxResult | SignDeployContractChainedTxResult | SignExecuteScriptChainedTxResult;
-export interface SignGrouplessTransferTxParams {
-    fromAddress: string;
-    destinations: Destination[];
-    gasPrice?: Number256;
-    targetBlockHash?: string;
-}
-export interface SignGrouplessDeployContractTxParams {
-    fromAddress: string;
-    bytecode: string;
-    initialAttoAlphAmount?: Number256;
-    initialTokenAmounts?: Token[];
-    issueTokenAmount?: Number256;
-    issueTokenTo?: string;
-    gasPrice?: Number256;
-    targetBlockHash?: string;
-}
-export interface SignGrouplessExecuteScriptTxParams {
-    fromAddress: string;
-    bytecode: string;
-    attoAlphAmount?: Number256;
-    tokens?: Token[];
-    gasPrice?: Number256;
-    targetBlockHash?: string;
-    gasEstimationMultiplier?: number;
-}
-export type SignGrouplessTxParams = SignGrouplessTransferTxParams | SignGrouplessDeployContractTxParams | SignGrouplessExecuteScriptTxParams;
 export type MessageHasher = 'alephium' | 'sha256' | 'blake2b' | 'identity';
 export interface SignMessageParams {
     signerAddress: string;

package/dist/src/signer/types.js

@@ -28,6 +28,3 @@ utils_1.assertType;
 (0, utils_1.assertType)();
 utils_1.assertType;
 (0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();

package/dist/src/utils/sign.js

@@ -60,7 +60,7 @@ necc.utils.hmacSha256Sync = (key, ...messages) => {
 // hash has to be 32 bytes
 function sign(hash, privateKey, _keyType) {
     const keyType = _keyType ?? 'default';
-    if (keyType === 'default' || keyType === 'groupless') {
+    if (keyType === 'default' || keyType === 'gl-secp256k1') {
         const key = ec.keyFromPrivate(privateKey);
         const signature = key.sign(hash);
         return (0, utils_1.encodeSignature)(signature);
@@ -74,7 +74,7 @@ exports.sign = sign;
 function verifySignature(hash, publicKey, signature, _keyType) {
     const keyType = _keyType ?? 'default';
     try {
-        if (keyType === 'default' || keyType === 'groupless') {
+        if (keyType === 'default' || keyType === 'gl-secp256k1') {
             const key = ec.keyFromPublic(publicKey, 'hex');
             return key.verify(hash, (0, utils_1.signatureDecode)(ec, signature));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "1.12.0-beta.0",
+  "version": "1.12.0-danube.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",