@alephium/web3 0.2.0-rc.30 → 0.2.0-rc.32

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

@@ -1,7 +1,18 @@
 import { Api as NodeApi } from './api-alephium';
 import { Api as ExplorerApi } from './api-explorer';
-export declare class NodeProvider extends NodeApi<string> {
+export declare class NodeProvider {
+    wallets: NodeApi<string>['wallets'];
+    infos: NodeApi<string>['infos'];
+    blockflow: NodeApi<string>['blockflow'];
+    addresses: NodeApi<string>['addresses'];
+    transactions: NodeApi<string>['transactions'];
+    contracts: NodeApi<string>['contracts'];
+    multisig: NodeApi<string>['multisig'];
+    utils: NodeApi<string>['utils'];
+    miners: NodeApi<string>['miners'];
+    events: NodeApi<string>['events'];
     constructor(baseUrl: string, apiKey?: string);
+    reset(baseUrl: string, apiKey?: string): void;
 }
 export declare class ExplorerProvider extends ExplorerApi<null> {
     constructor(baseUrl: string);

package/dist/src/api/index.js

@@ -46,23 +46,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.explorer = exports.node = exports.ExplorerProvider = exports.NodeProvider = void 0;
 const api_alephium_1 = require("./api-alephium");
 const api_explorer_1 = require("./api-explorer");
-class NodeProvider extends api_alephium_1.Api {
+function initializeNodeApi(baseUrl, apiKey) {
+    const nodeApi = new api_alephium_1.Api({
+        baseUrl: baseUrl,
+        baseApiParams: { secure: true },
+        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+    });
+    nodeApi.setSecurityData(apiKey ?? null);
+    return nodeApi;
+}
+class NodeProvider {
     constructor(baseUrl, apiKey) {
-        // eslint-disable-next-line security/detect-possible-timing-attacks
-        if (apiKey === undefined) {
-            super({ baseUrl: baseUrl });
-        }
-        else {
-            super({
-                baseUrl: baseUrl,
-                baseApiParams: { secure: true },
-                securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-            });
-            this.setSecurityData(apiKey);
-        }
+        const nodeApi = initializeNodeApi(baseUrl, apiKey);
+        this.wallets = nodeApi.wallets;
+        this.infos = nodeApi.infos;
+        this.blockflow = nodeApi.blockflow;
+        this.addresses = nodeApi.addresses;
+        this.transactions = nodeApi.transactions;
+        this.contracts = nodeApi.contracts;
+        this.multisig = nodeApi.multisig;
+        this.utils = nodeApi.utils;
+        this.miners = nodeApi.miners;
+        this.events = nodeApi.events;
+    }
+    // Have to duplicate the code above due to proxy pattern
+    reset(baseUrl, apiKey) {
+        const nodeApi = initializeNodeApi(baseUrl, apiKey);
+        this.wallets = nodeApi.wallets;
+        this.infos = nodeApi.infos;
+        this.blockflow = nodeApi.blockflow;
+        this.addresses = nodeApi.addresses;
+        this.transactions = nodeApi.transactions;
+        this.contracts = nodeApi.contracts;
+        this.multisig = nodeApi.multisig;
+        this.utils = nodeApi.utils;
+        this.miners = nodeApi.miners;
+        this.events = nodeApi.events;
     }
 }
 exports.NodeProvider = NodeProvider;
+// TODO: use proxy provider once the endpoints are refined.
 class ExplorerProvider extends api_explorer_1.Api {
     constructor(baseUrl) {
         super({ baseUrl: baseUrl });

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

@@ -1,5 +1,5 @@
 import { NamedVals, node, Number256, Token, Val } from '../api';
-import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerProvider } from '../signer';
 export declare type FieldsSig = node.FieldsSig;
 export declare type EventSig = node.EventSig;
 export declare type FunctionSig = node.FunctionSig;
@@ -122,7 +122,7 @@ export declare class Contract extends Artifact {
     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: SignerWithNodeProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
+    transactionForDeployment(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
 export declare class Script extends Artifact {
@@ -135,7 +135,7 @@ export declare class Script extends Artifact {
     static fromArtifactFile(path: string, bytecodeDebugPatch: string): Promise<Script>;
     toString(): string;
     paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams>;
-    transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
+    transactionForDeployment(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
 export interface Asset {
@@ -218,7 +218,6 @@ export interface BuildDeployContractTx {
     issueTokenAmount?: Number256;
     gasAmount?: number;
     gasPrice?: Number256;
-    submitTx?: boolean;
 }
 export interface BuildExecuteScriptTx {
     signerAddress: string;
@@ -227,7 +226,6 @@ export interface BuildExecuteScriptTx {
     tokens?: Token[];
     gasAmount?: number;
     gasPrice?: Number256;
-    submitTx?: boolean;
 }
 export interface BuildScriptTxResult {
     fromGroup: number;

package/dist/src/contract/contract.js

@@ -598,7 +598,7 @@ class Contract extends Artifact {
     async transactionForDeployment(signer, params) {
         const signerParams = await this.paramsForDeployment({
             ...params,
-            signerAddress: (await signer.getActiveAccount()).address
+            signerAddress: (await signer.getSelectedAccount()).address
         });
         const response = await signer.buildContractCreationTx(signerParams);
         return fromApiDeployContractUnsignedTx(response);
@@ -666,7 +666,7 @@ class Script extends Artifact {
     async transactionForDeployment(signer, params) {
         const signerParams = await this.paramsForDeployment({
             ...params,
-            signerAddress: (await signer.getActiveAccount()).address
+            signerAddress: (await signer.getSelectedAccount()).address
         });
         return await signer.buildScriptTx(signerParams);
     }

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

@@ -1,4 +1,4 @@
-import { Number256, Token } from '../api';
+import { NodeProvider, Number256, Token } from '../api';
 import { node } from '../api';
 export declare type OutputRef = node.OutputRef;
 export interface SignResult {
@@ -13,9 +13,6 @@ export interface Account {
     group: number;
     publicKey: string;
 }
-export declare type SubmitTx = {
-    submitTx?: boolean;
-};
 export declare type SignerAddress = {
     signerAddress: string;
 };
@@ -27,7 +24,6 @@ export interface SignTransferTxParams {
     utxos?: OutputRef[];
     gasAmount?: number;
     gasPrice?: Number256;
-    submitTx?: boolean;
 }
 export interface SignTransferTxResult {
     fromGroup: number;
@@ -44,7 +40,6 @@ export interface SignDeployContractTxParams {
     issueTokenAmount?: Number256;
     gasAmount?: number;
     gasPrice?: Number256;
-    submitTx?: boolean;
 }
 export interface SignDeployContractTxResult {
     fromGroup: number;
@@ -62,7 +57,6 @@ export interface SignExecuteScriptTxParams {
     tokens?: Token[];
     gasAmount?: number;
     gasPrice?: string;
-    submitTx?: boolean;
 }
 export interface SignExecuteScriptTxResult {
     fromGroup: number;
@@ -74,7 +68,6 @@ export interface SignExecuteScriptTxResult {
 export interface SignUnsignedTxParams {
     signerAddress: string;
     unsignedTx: string;
-    submitTx?: boolean;
 }
 export interface SignUnsignedTxResult {
     fromGroup: number;
@@ -97,8 +90,8 @@ export interface SignMessageParams {
 export interface SignMessageResult {
     signature: string;
 }
-export interface SignerProvider {
-    getAccounts(): Promise<Account[]>;
+export interface SignerProviderWithoutNodeProvider {
+    getSelectedAccount(): Promise<Account>;
     signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
     signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
@@ -106,17 +99,14 @@ export interface SignerProvider {
     signHexString(params: SignHexStringParams): Promise<SignHexStringResult>;
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
 }
-export declare abstract class SignerWithNodeProvider implements SignerProvider {
-    alwaysSubmitTx: boolean;
-    abstract getAccounts(): Promise<Account[]>;
-    getAccount(signerAddress: string): Promise<Account>;
-    abstract setActiveAccount(addressIndex: number): Promise<void>;
-    abstract setActiveAccount(address: string): Promise<void>;
-    abstract setActiveAccount(input: unknown): Promise<void>;
-    abstract getActiveAccount(): Promise<Account>;
-    constructor(alwaysSubmitTx: boolean);
-    submitTransaction(unsignedTx: string, signerAddress?: string): Promise<SubmissionResult>;
-    private shouldSubmitTx;
+export declare abstract class SignerProvider implements SignerProviderWithoutNodeProvider {
+    abstract get nodeProvider(): NodeProvider;
+    abstract getSelectedAccount(): Promise<Account>;
+    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>;
     private usePublicKey;
     signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult>;
@@ -131,11 +121,16 @@ export declare abstract class SignerWithNodeProvider implements SignerProvider {
         signerAddress: string;
         unsignedTx: string;
         txId: string;
-    }, submitTx: boolean): Promise<SignResult>;
+    }): 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 {
+    abstract getAccounts(): Promise<Account[]>;
+    getAccount(signerAddress: string): Promise<Account>;
+    abstract setSelectedAccount(address: string): Promise<void>;
+}
 export interface SubmissionResult {
     txId: string;
     fromGroup: number;

package/dist/src/signer/signer.js

@@ -43,13 +43,12 @@ 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.SignerWithNodeProvider = void 0;
+exports.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.verifyHexString = exports.SignerProviderWithMultipleAccounts = exports.SignerProvider = void 0;
 const elliptic_1 = require("elliptic");
 const api_1 = require("../api");
 const utils = __importStar(require("../utils"));
 const utils_1 = require("../utils");
 const blakejs_1 = __importDefault(require("blakejs"));
-const __1 = require("..");
 const ec = new elliptic_1.ec('secp256k1');
 (0, utils_1.assertType)();
 (0, utils_1.assertType)();
@@ -63,47 +62,40 @@ const ec = new elliptic_1.ec('secp256k1');
 (0, utils_1.assertType)();
 (0, utils_1.assertType)();
 (0, utils_1.assertType)();
-class SignerWithNodeProvider {
-    constructor(alwaysSubmitTx) {
-        this.alwaysSubmitTx = alwaysSubmitTx;
+class SignerProvider {
+    async submitTransaction(unsignedTx, signature) {
+        const params = { unsignedTx: unsignedTx, signature: signature };
+        return this.nodeProvider.transactions.postTransactionsSubmit(params);
     }
-    async getAccount(signerAddress) {
-        const accounts = await this.getAccounts();
-        const account = accounts.find((a) => a.address === signerAddress);
-        if (typeof account === 'undefined') {
-            throw new Error('Unmatched signerAddress');
-        }
-        else {
-            return account;
-        }
+    async signAndSubmitTransferTx(params) {
+        const signResult = await this.signTransferTx(params);
+        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
     }
-    async submitTransaction(unsignedTx, signerAddress) {
-        const decoded = await __1.web3
-            .getCurrentNodeProvider()
-            .transactions.postTransactionsDecodeUnsignedTx({ unsignedTx: unsignedTx });
-        const txId = decoded.unsignedTx.txId;
-        const address = typeof signerAddress !== 'undefined' ? signerAddress : (await this.getActiveAccount()).address;
-        const signature = await this.signRaw(address, txId);
-        const params = { unsignedTx: unsignedTx, signature: signature };
-        return __1.web3.getCurrentNodeProvider().transactions.postTransactionsSubmit(params);
+    async signAndSubmitDeployContractTx(params) {
+        const signResult = await this.signDeployContractTx(params);
+        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
+    }
+    async signAndSubmitExecuteScriptTx(params) {
+        const signResult = await this.signExecuteScriptTx(params);
+        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
     }
-    shouldSubmitTx(params) {
-        return this.alwaysSubmitTx || (params.submitTx ? params.submitTx : true);
+    async signAndSubmitUnsignedTx(params) {
+        const signResult = await this.signUnsignedTx(params);
+        return this.submitTransaction(signResult.unsignedTx, signResult.signature);
     }
     async usePublicKey(params) {
         const { signerAddress, ...restParams } = params;
-        const allAccounts = await this.getAccounts();
-        const signerAccount = allAccounts.find((account) => account.address === signerAddress);
-        if (typeof signerAccount === 'undefined') {
-            throw new Error('Unknown signer address');
+        const selectedAccount = await this.getSelectedAccount();
+        if (signerAddress !== selectedAccount.address) {
+            throw new Error('The signer address is not the selected address');
         }
         else {
-            return { fromPublicKey: signerAccount.publicKey, ...restParams };
+            return { fromPublicKey: selectedAccount.publicKey, ...restParams };
         }
     }
     async signTransferTx(params) {
         const response = await this.buildTransferTx(params);
-        return this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params));
+        return this.handleSign({ signerAddress: params.signerAddress, ...response });
     }
     async buildTransferTx(params) {
         const data = {
@@ -111,11 +103,11 @@ class SignerWithNodeProvider {
             destinations: toApiDestinations(params.destinations),
             gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
         };
-        return __1.web3.getCurrentNodeProvider().transactions.postTransactionsBuild(data);
+        return this.nodeProvider.transactions.postTransactionsBuild(data);
     }
     async signDeployContractTx(params) {
         const response = await this.buildContractCreationTx(params);
-        const result = await this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params));
+        const result = await this.handleSign({ signerAddress: params.signerAddress, ...response });
         const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress));
         return { ...result, contractId: contractId, contractAddress: response.contractAddress };
     }
@@ -127,43 +119,35 @@ class SignerWithNodeProvider {
             issueTokenAmount: (0, api_1.toApiNumber256Optional)(params.issueTokenAmount),
             gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
         };
-        return __1.web3.getCurrentNodeProvider().contracts.postContractsUnsignedTxDeployContract(data);
+        return this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
     }
     async signExecuteScriptTx(params) {
         const response = await this.buildScriptTx(params);
-        return this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params));
+        return this.handleSign({ signerAddress: params.signerAddress, ...response });
     }
     async buildScriptTx(params) {
         const data = {
             ...(await this.usePublicKey(params)),
             tokens: (0, api_1.toApiTokens)(params.tokens)
         };
-        return __1.web3.getCurrentNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data);
+        return this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
     }
     // in general, wallet should show the decoded information to user for confirmation
     // please overwrite this function for real wallet
     async signUnsignedTx(params) {
         const data = { unsignedTx: params.unsignedTx };
-        const decoded = await __1.web3.getCurrentNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data);
+        const decoded = await this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data);
         return this.handleSign({
             fromGroup: decoded.fromGroup,
             toGroup: decoded.toGroup,
             signerAddress: params.signerAddress,
             unsignedTx: params.unsignedTx,
             txId: decoded.unsignedTx.txId
-        }, params.submitTx ? params.submitTx : true // we don't consider `alwaysSubmitTx` as the tx might needs multiple signatures
-        );
+        });
     }
-    async handleSign(response, submitTx) {
+    async handleSign(response) {
         // sign the tx
         const signature = await this.signRaw(response.signerAddress, response.txId);
-        // submit the tx if required
-        if (submitTx) {
-            await __1.web3.getCurrentNodeProvider().transactions.postTransactionsSubmit({
-                unsignedTx: response.unsignedTx,
-                signature: signature
-            });
-        }
         // return the signature back to the provider
         return {
             fromGroup: response.fromGroup,
@@ -184,7 +168,20 @@ class SignerWithNodeProvider {
         return { signature: signature };
     }
 }
-exports.SignerWithNodeProvider = SignerWithNodeProvider;
+exports.SignerProvider = SignerProvider;
+class SignerProviderWithMultipleAccounts extends SignerProvider {
+    async getAccount(signerAddress) {
+        const accounts = await this.getAccounts();
+        const account = accounts.find((a) => a.address === signerAddress);
+        if (typeof account === 'undefined') {
+            throw new Error('Unmatched signerAddress');
+        }
+        else {
+            return account;
+        }
+    }
+}
+exports.SignerProviderWithMultipleAccounts = SignerProviderWithMultipleAccounts;
 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.30",
+  "version": "0.2.0-rc.32",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",

package/src/api/index.ts

@@ -19,22 +19,61 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import { Api as NodeApi } from './api-alephium'
 import { Api as ExplorerApi } from './api-explorer'
 
-export class NodeProvider extends NodeApi<string> {
+function initializeNodeApi(baseUrl: string, apiKey?: string): NodeApi<string> {
+  const nodeApi = new NodeApi<string>({
+    baseUrl: baseUrl,
+    baseApiParams: { secure: true },
+    securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+  })
+  nodeApi.setSecurityData(apiKey ?? null)
+  return nodeApi
+}
+
+export class NodeProvider {
+  wallets: NodeApi<string>['wallets']
+  infos: NodeApi<string>['infos']
+  blockflow: NodeApi<string>['blockflow']
+  addresses: NodeApi<string>['addresses']
+  transactions: NodeApi<string>['transactions']
+  contracts: NodeApi<string>['contracts']
+  multisig: NodeApi<string>['multisig']
+  utils: NodeApi<string>['utils']
+  miners: NodeApi<string>['miners']
+  events: NodeApi<string>['events']
+
   constructor(baseUrl: string, apiKey?: string) {
-    // eslint-disable-next-line security/detect-possible-timing-attacks
-    if (apiKey === undefined) {
-      super({ baseUrl: baseUrl })
-    } else {
-      super({
-        baseUrl: baseUrl,
-        baseApiParams: { secure: true },
-        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-      })
-      this.setSecurityData(apiKey)
-    }
+    const nodeApi = initializeNodeApi(baseUrl, apiKey)
+
+    this.wallets = nodeApi.wallets
+    this.infos = nodeApi.infos
+    this.blockflow = nodeApi.blockflow
+    this.addresses = nodeApi.addresses
+    this.transactions = nodeApi.transactions
+    this.contracts = nodeApi.contracts
+    this.multisig = nodeApi.multisig
+    this.utils = nodeApi.utils
+    this.miners = nodeApi.miners
+    this.events = nodeApi.events
+  }
+
+  // Have to duplicate the code above due to proxy pattern
+  reset(baseUrl: string, apiKey?: string): void {
+    const nodeApi = initializeNodeApi(baseUrl, apiKey)
+
+    this.wallets = nodeApi.wallets
+    this.infos = nodeApi.infos
+    this.blockflow = nodeApi.blockflow
+    this.addresses = nodeApi.addresses
+    this.transactions = nodeApi.transactions
+    this.contracts = nodeApi.contracts
+    this.multisig = nodeApi.multisig
+    this.utils = nodeApi.utils
+    this.miners = nodeApi.miners
+    this.events = nodeApi.events
   }
 }
 
+// TODO: use proxy provider once the endpoints are refined.
 export class ExplorerProvider extends ExplorerApi<null> {
   constructor(baseUrl: string) {
     super({ baseUrl: baseUrl })

package/src/contract/contract.ts

@@ -36,7 +36,7 @@ import {
   fromApiTokens,
   fromApiVals
 } from '../api'
-import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer'
+import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerProvider } from '../signer'
 import * as ralph from './ralph'
 import { bs58, binToHex, contractIdFromAddress, assertType, Eq } from '../utils'
 import { getCurrentNodeProvider } from '../global'
@@ -823,12 +823,12 @@ export class Contract extends Artifact {
   }
 
   async transactionForDeployment(
-    signer: SignerWithNodeProvider,
+    signer: SignerProvider,
     params: Omit<BuildDeployContractTx, 'signerAddress'>
   ): Promise<DeployContractTransaction> {
     const signerParams = await this.paramsForDeployment({
       ...params,
-      signerAddress: (await signer.getActiveAccount()).address
+      signerAddress: (await signer.getSelectedAccount()).address
     })
     const response = await signer.buildContractCreationTx(signerParams)
     return fromApiDeployContractUnsignedTx(response)
@@ -909,12 +909,12 @@ export class Script extends Artifact {
   }
 
   async transactionForDeployment(
-    signer: SignerWithNodeProvider,
+    signer: SignerProvider,
     params: Omit<BuildExecuteScriptTx, 'signerAddress'>
   ): Promise<BuildScriptTxResult> {
     const signerParams = await this.paramsForDeployment({
       ...params,
-      signerAddress: (await signer.getActiveAccount()).address
+      signerAddress: (await signer.getSelectedAccount()).address
     })
     return await signer.buildScriptTx(signerParams)
   }
@@ -1112,7 +1112,6 @@ export interface BuildDeployContractTx {
   issueTokenAmount?: Number256
   gasAmount?: number
   gasPrice?: Number256
-  submitTx?: boolean
 }
 assertType<Eq<keyof BuildDeployContractTx, keyof BuildTxParams<SignDeployContractTxParams>>>()
 
@@ -1123,7 +1122,6 @@ export interface BuildExecuteScriptTx {
   tokens?: Token[]
   gasAmount?: number
   gasPrice?: Number256
-  submitTx?: boolean
 }
 assertType<Eq<keyof BuildExecuteScriptTx, keyof BuildTxParams<SignExecuteScriptTxParams>>>()