@alephium/web3 0.2.0-rc.33 → 0.2.0-rc.34

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

@@ -27,6 +27,24 @@ export declare class NodeProvider implements INodeProvider {
     constructor(baseUrl: string, apiKey?: string);
     static Proxy(nodeProvider: NodeProvider): NodeProvider;
 }
+export interface RequestArguments {
+    path: string;
+    method: string;
+    params?: any;
+}
+export declare class RemoteNodeProvider implements INodeProvider {
+    readonly wallets: NodeApi<string>['wallets'];
+    readonly infos: NodeApi<string>['infos'];
+    readonly blockflow: NodeApi<string>['blockflow'];
+    readonly addresses: NodeApi<string>['addresses'];
+    readonly transactions: NodeApi<string>['transactions'];
+    readonly contracts: NodeApi<string>['contracts'];
+    readonly multisig: NodeApi<string>['multisig'];
+    readonly utils: NodeApi<string>['utils'];
+    readonly miners: NodeApi<string>['miners'];
+    readonly events: NodeApi<string>['events'];
+    constructor(request: (request: RequestArguments) => Promise<any>);
+}
 export declare class ExplorerProvider extends ExplorerApi<null> {
     constructor(baseUrl: string);
 }

package/dist/src/api/index.js

@@ -43,7 +43,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.explorer = exports.node = exports.ExplorerProvider = exports.NodeProvider = void 0;
+exports.explorer = exports.node = exports.ExplorerProvider = exports.RemoteNodeProvider = exports.NodeProvider = void 0;
 const api_alephium_1 = require("./api-alephium");
 const api_explorer_1 = require("./api-explorer");
 function initializeNodeApi(baseUrl, apiKey) {
@@ -81,6 +81,21 @@ class NodeProvider {
     }
 }
 exports.NodeProvider = NodeProvider;
+class RemoteNodeProvider {
+    constructor(request) {
+        const fakeNodeProvide = new NodeProvider('https://1.2.3.4:12973');
+        Object.assign(this, fakeNodeProvide); // Initialize the class
+        // Update class properties to forward requests
+        for (const [path, pathObject] of Object.entries(this)) {
+            for (const method of Object.keys(pathObject)) {
+                pathObject[`${method}`] = async (params) => {
+                    return request({ path, method, params });
+                };
+            }
+        }
+    }
+}
+exports.RemoteNodeProvider = RemoteNodeProvider;
 // TODO: use proxy provider once the endpoints are refined.
 class ExplorerProvider extends api_explorer_1.Api {
     constructor(baseUrl) {

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

@@ -121,8 +121,8 @@ export declare class Contract extends Artifact {
     static ContractDestroyedEvent: EventSig;
     static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): Promise<ContractEventByTxId>;
     fromTestContractResult(methodIndex: number, result: node.TestContractResult): Promise<TestContractResult>;
-    paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams>;
-    transactionForDeployment(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
+    txParamsForDeployment(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<SignDeployContractTxParams>;
+    deploy(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
 export declare class Script extends Artifact {
@@ -134,8 +134,8 @@ export declare class Script extends Artifact {
     static fromJson(artifact: any, bytecodeDebugPatch?: string): Script;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string): Promise<Script>;
     toString(): string;
-    paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams>;
-    transactionForDeployment(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
+    txParamsForExecution(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<SignExecuteScriptTxParams>;
+    execute(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
 export interface Asset {

package/dist/src/contract/contract.js

@@ -582,10 +582,10 @@ class Contract extends Artifact {
             debugMessages: result.debugMessages
         };
     }
-    async paramsForDeployment(params) {
+    async txParamsForDeployment(signer, params) {
         const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {});
         const signerParams = {
-            signerAddress: params.signerAddress,
+            signerAddress: (await signer.getSelectedAccount()).address,
             bytecode: bytecode,
             initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
             issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
@@ -595,13 +595,9 @@ class Contract extends Artifact {
         };
         return signerParams;
     }
-    async transactionForDeployment(signer, params) {
-        const signerParams = await this.paramsForDeployment({
-            ...params,
-            signerAddress: (await signer.getSelectedAccount()).address
-        });
-        const response = await signer.buildContractCreationTx(signerParams);
-        return fromApiDeployContractUnsignedTx(response);
+    async deploy(signer, params) {
+        const signerParams = await this.txParamsForDeployment(signer, params);
+        return signer.signAndSubmitDeployContractTx(signerParams);
     }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildContractByteCode(this.bytecode, initialFields, this.fieldsSig);
@@ -652,9 +648,9 @@ class Script extends Artifact {
         };
         return JSON.stringify(object, null, 2);
     }
-    async paramsForDeployment(params) {
+    async txParamsForExecution(signer, params) {
         const signerParams = {
-            signerAddress: params.signerAddress,
+            signerAddress: (await signer.getSelectedAccount()).address,
             bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
             attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
             tokens: (0, api_1.toApiTokens)(params.tokens),
@@ -663,12 +659,9 @@ class Script extends Artifact {
         };
         return signerParams;
     }
-    async transactionForDeployment(signer, params) {
-        const signerParams = await this.paramsForDeployment({
-            ...params,
-            signerAddress: (await signer.getSelectedAccount()).address
-        });
-        return await signer.buildScriptTx(signerParams);
+    async execute(signer, params) {
+        const signerParams = await this.txParamsForExecution(signer, params);
+        return await signer.signAndSubmitExecuteScriptTx(signerParams);
     }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig);
@@ -758,8 +751,5 @@ function fromApiOutput(output) {
         throw new Error(`Unknown output type: ${output}`);
     }
 }
-function fromApiDeployContractUnsignedTx(result) {
-    return { ...result, contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.contractAddress)) };
-}
 (0, utils_1.assertType)();
 (0, utils_1.assertType)();

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

@@ -1,13 +1,6 @@
 import { NodeProvider, Number256, Token } from '../api';
 import { node } from '../api';
 export declare type OutputRef = node.OutputRef;
-export interface SignResult {
-    fromGroup: number;
-    toGroup: number;
-    unsignedTx: string;
-    txId: string;
-    signature: string;
-}
 export interface Account {
     address: string;
     group: number;
@@ -16,8 +9,6 @@ export interface Account {
 export declare type SignerAddress = {
     signerAddress: string;
 };
-export declare type GetAccountsParams = undefined;
-export declare type GetAccountsResult = Account[];
 export interface SignTransferTxParams {
     signerAddress: string;
     destinations: Destination[];
@@ -31,6 +22,8 @@ export interface SignTransferTxResult {
     unsignedTx: string;
     txId: string;
     signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
 }
 export interface SignDeployContractTxParams {
     signerAddress: string;
@@ -49,6 +42,8 @@ export interface SignDeployContractTxResult {
     signature: string;
     contractId: string;
     contractAddress: string;
+    gasAmount: number;
+    gasPrice: Number256;
 }
 export interface SignExecuteScriptTxParams {
     signerAddress: string;
@@ -64,6 +59,8 @@ export interface SignExecuteScriptTxResult {
     unsignedTx: string;
     txId: string;
     signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
 }
 export interface SignUnsignedTxParams {
     signerAddress: string;
@@ -75,13 +72,8 @@ export interface SignUnsignedTxResult {
     unsignedTx: string;
     txId: string;
     signature: string;
-}
-export interface SignHexStringParams {
-    signerAddress: string;
-    hexString: string;
-}
-export interface SignHexStringResult {
-    signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
 }
 export interface SignMessageParams {
     signerAddress: string;
@@ -90,15 +82,34 @@ export interface SignMessageParams {
 export interface SignMessageResult {
     signature: string;
 }
-export declare abstract class SignerProvider {
+export interface SubmitTransactionParams {
+    unsignedTx: string;
+    signature: string;
+}
+export interface SubmissionResult {
+    txId: string;
+    fromGroup: number;
+    toGroup: number;
+}
+export interface SignerProvider {
+    get nodeProvider(): NodeProvider | undefined;
+    getSelectedAccount(): Promise<Account>;
+    signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
+    signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signMessage(params: SignMessageParams): Promise<SignMessageResult>;
+}
+export declare abstract class SignerProviderSimple implements SignerProvider {
     abstract get nodeProvider(): NodeProvider | undefined;
     abstract getSelectedAccount(): Promise<Account>;
     private getNodeProvider;
-    submitTransaction(unsignedTx: string, signature: string): Promise<SubmissionResult>;
-    signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SubmissionResult>;
-    signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SubmissionResult>;
-    signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SubmissionResult>;
-    signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SubmissionResult>;
+    submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult>;
+    signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
+    signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
     private usePublicKey;
     signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult>;
@@ -107,34 +118,14 @@ export declare abstract class SignerProvider {
     signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
     buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult>;
     signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
-    protected handleSign(response: {
-        fromGroup: number;
-        toGroup: number;
-        signerAddress: string;
-        unsignedTx: string;
-        txId: string;
-    }): Promise<SignResult>;
-    signHexString(params: SignHexStringParams): Promise<SignHexStringResult>;
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
     abstract signRaw(signerAddress: string, hexString: string): Promise<string>;
 }
-export declare abstract class SignerProviderWithMultipleAccounts extends SignerProvider {
+export declare abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
     abstract getAccounts(): Promise<Account[]>;
     getAccount(signerAddress: string): Promise<Account>;
     abstract setSelectedAccount(address: string): Promise<void>;
 }
-export declare class SignerProviderWrapper extends SignerProvider {
-    signer: SignerProvider;
-    nodeProvider: NodeProvider;
-    constructor(signer: SignerProvider, nodeProvider: NodeProvider);
-    getSelectedAccount(): Promise<Account>;
-    signRaw(signerAddress: string, hexString: string): Promise<string>;
-}
-export interface SubmissionResult {
-    txId: string;
-    fromGroup: number;
-    toGroup: number;
-}
 export declare function verifyHexString(hexString: string, publicKey: string, signature: string): boolean;
 export declare function verifySignedMessage(message: string, publicKey: string, signature: string): boolean;
 export interface Destination {

package/dist/src/signer/signer.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.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.verifyHexString = exports.SignerProviderWrapper = exports.SignerProviderWithMultipleAccounts = exports.SignerProvider = void 0;
+exports.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.verifyHexString = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = void 0;
 const elliptic_1 = require("elliptic");
 const api_1 = require("../api");
 const utils = __importStar(require("../utils"));
@@ -57,37 +57,38 @@ const ec = new elliptic_1.ec('secp256k1');
 (0, utils_1.assertType)();
 (0, 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)();
-(0, utils_1.assertType)();
-class SignerProvider {
+class SignerProviderSimple {
     getNodeProvider() {
         if (this.nodeProvider === undefined) {
             throw Error('The signer does not contain a node provider');
         }
         return this.nodeProvider;
     }
-    async submitTransaction(unsignedTx, signature) {
-        const params = { unsignedTx: unsignedTx, signature: signature };
-        return this.getNodeProvider().transactions.postTransactionsSubmit(params);
+    async submitTransaction(params) {
+        const data = { unsignedTx: params.unsignedTx, signature: params.signature };
+        return this.getNodeProvider().transactions.postTransactionsSubmit(data);
     }
     async signAndSubmitTransferTx(params) {
         const signResult = await this.signTransferTx(params);
-        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
+        await this.submitTransaction(signResult);
+        return signResult;
     }
     async signAndSubmitDeployContractTx(params) {
         const signResult = await this.signDeployContractTx(params);
-        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
+        await this.submitTransaction(signResult);
+        return signResult;
     }
     async signAndSubmitExecuteScriptTx(params) {
         const signResult = await this.signExecuteScriptTx(params);
-        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
+        await this.submitTransaction(signResult);
+        return signResult;
     }
     async signAndSubmitUnsignedTx(params) {
         const signResult = await this.signUnsignedTx(params);
-        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
+        await this.submitTransaction(signResult);
+        return signResult;
     }
     async usePublicKey(params) {
         const { signerAddress, ...restParams } = params;
@@ -101,7 +102,8 @@ class SignerProvider {
     }
     async signTransferTx(params) {
         const response = await this.buildTransferTx(params);
-        return this.handleSign({ signerAddress: params.signerAddress, ...response });
+        const signature = await this.signRaw(params.signerAddress, response.txId);
+        return { ...response, signature, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildTransferTx(params) {
         const data = {
@@ -113,9 +115,9 @@ class SignerProvider {
     }
     async signDeployContractTx(params) {
         const response = await this.buildContractCreationTx(params);
-        const result = await this.handleSign({ signerAddress: params.signerAddress, ...response });
+        const signature = await this.signRaw(params.signerAddress, response.txId);
         const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress));
-        return { ...result, contractId: contractId, contractAddress: response.contractAddress };
+        return { ...response, contractId, signature, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildContractCreationTx(params) {
         const data = {
@@ -129,7 +131,8 @@ class SignerProvider {
     }
     async signExecuteScriptTx(params) {
         const response = await this.buildScriptTx(params);
-        return this.handleSign({ signerAddress: params.signerAddress, ...response });
+        const signature = await this.signRaw(params.signerAddress, response.txId);
+        return { ...response, signature, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildScriptTx(params) {
         const data = {
@@ -143,30 +146,17 @@ class SignerProvider {
     async signUnsignedTx(params) {
         const data = { unsignedTx: params.unsignedTx };
         const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data);
-        return this.handleSign({
+        const signature = await this.signRaw(params.signerAddress, decoded.unsignedTx.txId);
+        return {
             fromGroup: decoded.fromGroup,
             toGroup: decoded.toGroup,
-            signerAddress: params.signerAddress,
             unsignedTx: params.unsignedTx,
-            txId: decoded.unsignedTx.txId
-        });
-    }
-    async handleSign(response) {
-        // sign the tx
-        const signature = await this.signRaw(response.signerAddress, response.txId);
-        // return the signature back to the provider
-        return {
-            fromGroup: response.fromGroup,
-            toGroup: response.toGroup,
-            unsignedTx: response.unsignedTx,
-            txId: response.txId,
-            signature: signature
+            txId: decoded.unsignedTx.txId,
+            signature,
+            gasAmount: decoded.unsignedTx.gasAmount,
+            gasPrice: (0, api_1.fromApiNumber256)(decoded.unsignedTx.gasPrice)
         };
     }
-    async signHexString(params) {
-        const signature = await this.signRaw(params.signerAddress, params.hexString);
-        return { signature: signature };
-    }
     async signMessage(params) {
         const extendedMessage = extendMessage(params.message);
         const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
@@ -174,8 +164,8 @@ class SignerProvider {
         return { signature: signature };
     }
 }
-exports.SignerProvider = SignerProvider;
-class SignerProviderWithMultipleAccounts extends SignerProvider {
+exports.SignerProviderSimple = SignerProviderSimple;
+class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
     async getAccount(signerAddress) {
         const accounts = await this.getAccounts();
         const account = accounts.find((a) => a.address === signerAddress);
@@ -188,20 +178,6 @@ class SignerProviderWithMultipleAccounts extends SignerProvider {
     }
 }
 exports.SignerProviderWithMultipleAccounts = SignerProviderWithMultipleAccounts;
-class SignerProviderWrapper extends SignerProvider {
-    constructor(signer, nodeProvider) {
-        super();
-        this.signer = signer;
-        this.nodeProvider = nodeProvider;
-    }
-    getSelectedAccount() {
-        return this.signer.getSelectedAccount();
-    }
-    signRaw(signerAddress, hexString) {
-        return this.signer.signRaw(signerAddress, hexString);
-    }
-}
-exports.SignerProviderWrapper = SignerProviderWrapper;
 function verifyHexString(hexString, publicKey, signature) {
     try {
         const key = ec.keyFromPublic(publicKey, 'hex');

package/package.json

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

package/src/api/index.ts

@@ -82,6 +82,39 @@ export class NodeProvider implements INodeProvider {
   }
 }
 
+export interface RequestArguments {
+  path: string
+  method: string
+  params?: any
+}
+
+export class RemoteNodeProvider implements INodeProvider {
+  readonly wallets!: NodeApi<string>['wallets']
+  readonly infos!: NodeApi<string>['infos']
+  readonly blockflow!: NodeApi<string>['blockflow']
+  readonly addresses!: NodeApi<string>['addresses']
+  readonly transactions!: NodeApi<string>['transactions']
+  readonly contracts!: NodeApi<string>['contracts']
+  readonly multisig!: NodeApi<string>['multisig']
+  readonly utils!: NodeApi<string>['utils']
+  readonly miners!: NodeApi<string>['miners']
+  readonly events!: NodeApi<string>['events']
+
+  constructor(request: (request: RequestArguments) => Promise<any>) {
+    const fakeNodeProvide = new NodeProvider('https://1.2.3.4:12973')
+    Object.assign(this, fakeNodeProvide) // Initialize the class
+
+    // Update class properties to forward requests
+    for (const [path, pathObject] of Object.entries(this)) {
+      for (const method of Object.keys(pathObject)) {
+        pathObject[`${method}`] = async (params: any): Promise<any> => {
+          return request({ path, method, params })
+        }
+      }
+    }
+  }
+}
+
 // TODO: use proxy provider once the endpoints are refined.
 export class ExplorerProvider extends ExplorerApi<null> {
   constructor(baseUrl: string) {

package/src/contract/contract.ts

@@ -808,10 +808,13 @@ export class Contract extends Artifact {
     }
   }
 
-  async paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams> {
+  async txParamsForDeployment(
+    signer: SignerProvider,
+    params: Omit<BuildDeployContractTx, 'signerAddress'>
+  ): Promise<SignDeployContractTxParams> {
     const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {})
     const signerParams: SignDeployContractTxParams = {
-      signerAddress: params.signerAddress,
+      signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: bytecode,
       initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
       issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
@@ -822,16 +825,12 @@ export class Contract extends Artifact {
     return signerParams
   }
 
-  async transactionForDeployment(
+  async deploy(
     signer: SignerProvider,
     params: Omit<BuildDeployContractTx, 'signerAddress'>
   ): Promise<DeployContractTransaction> {
-    const signerParams = await this.paramsForDeployment({
-      ...params,
-      signerAddress: (await signer.getSelectedAccount()).address
-    })
-    const response = await signer.buildContractCreationTx(signerParams)
-    return fromApiDeployContractUnsignedTx(response)
+    const signerParams = await this.txParamsForDeployment(signer, params)
+    return signer.signAndSubmitDeployContractTx(signerParams)
   }
 
   buildByteCodeToDeploy(initialFields: Fields): string {
@@ -896,9 +895,12 @@ export class Script extends Artifact {
     return JSON.stringify(object, null, 2)
   }
 
-  async paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams> {
+  async txParamsForExecution(
+    signer: SignerProvider,
+    params: Omit<BuildExecuteScriptTx, 'signerAddress'>
+  ): Promise<SignExecuteScriptTxParams> {
     const signerParams: SignExecuteScriptTxParams = {
-      signerAddress: params.signerAddress,
+      signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
       attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
       tokens: toApiTokens(params.tokens),
@@ -908,15 +910,12 @@ export class Script extends Artifact {
     return signerParams
   }
 
-  async transactionForDeployment(
+  async execute(
     signer: SignerProvider,
     params: Omit<BuildExecuteScriptTx, 'signerAddress'>
   ): Promise<BuildScriptTxResult> {
-    const signerParams = await this.paramsForDeployment({
-      ...params,
-      signerAddress: (await signer.getSelectedAccount()).address
-    })
-    return await signer.buildScriptTx(signerParams)
+    const signerParams = await this.txParamsForExecution(signer, params)
+    return await signer.signAndSubmitExecuteScriptTx(signerParams)
   }
 
   buildByteCodeToDeploy(initialFields: Fields): string {
@@ -1098,10 +1097,6 @@ export interface DeployContractTransaction {
   contractId: string
 }
 
-function fromApiDeployContractUnsignedTx(result: node.BuildDeployContractTxResult): DeployContractTransaction {
-  return { ...result, contractId: binToHex(contractIdFromAddress(result.contractAddress)) }
-}
-
 type BuildTxParams<T> = Omit<T, 'bytecode'> & { initialFields?: Val[] }
 
 export interface BuildDeployContractTx {