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

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

@@ -1,18 +1,49 @@
 import { Api as NodeApi } from './api-alephium';
 import { Api as ExplorerApi } from './api-explorer';
-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'];
+interface 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'];
+}
+export declare class NodeProvider 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(provider: INodeProvider);
     constructor(baseUrl: string, apiKey?: string);
-    reset(baseUrl: string, apiKey?: string): void;
+    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) {
@@ -56,8 +56,14 @@ function initializeNodeApi(baseUrl, apiKey) {
     return nodeApi;
 }
 class NodeProvider {
-    constructor(baseUrl, apiKey) {
-        const nodeApi = initializeNodeApi(baseUrl, apiKey);
+    constructor(param0, apiKey) {
+        let nodeApi;
+        if (typeof param0 === 'string') {
+            nodeApi = initializeNodeApi(param0, apiKey);
+        }
+        else {
+            nodeApi = param0;
+        }
         this.wallets = nodeApi.wallets;
         this.infos = nodeApi.infos;
         this.blockflow = nodeApi.blockflow;
@@ -69,22 +75,27 @@ class NodeProvider {
         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;
+    // This can prevent the proxied node provider from being modified
+    static Proxy(nodeProvider) {
+        return new NodeProvider(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,23 +82,34 @@ export interface SignMessageParams {
 export interface SignMessageResult {
     signature: string;
 }
-export interface SignerProviderWithoutNodeProvider {
+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>;
-    signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    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>;
-    signHexString(params: SignHexStringParams): Promise<SignHexStringResult>;
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
 }
-export declare abstract class SignerProvider implements SignerProviderWithoutNodeProvider {
-    abstract get nodeProvider(): NodeProvider;
+export declare abstract class SignerProviderSimple implements SignerProvider {
+    abstract get nodeProvider(): NodeProvider | undefined;
     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 getNodeProvider;
+    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>;
@@ -115,27 +118,14 @@ export declare abstract class SignerProvider implements SignerProviderWithoutNod
     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 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.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,31 +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 {
-    async submitTransaction(unsignedTx, signature) {
-        const params = { unsignedTx: unsignedTx, signature: signature };
-        return this.nodeProvider.transactions.postTransactionsSubmit(params);
+class SignerProviderSimple {
+    getNodeProvider() {
+        if (this.nodeProvider === undefined) {
+            throw Error('The signer does not contain a node provider');
+        }
+        return this.nodeProvider;
+    }
+    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;
@@ -95,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 = {
@@ -103,13 +111,13 @@ class SignerProvider {
             destinations: toApiDestinations(params.destinations),
             gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
         };
-        return this.nodeProvider.transactions.postTransactionsBuild(data);
+        return this.getNodeProvider().transactions.postTransactionsBuild(data);
     }
     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 = {
@@ -119,48 +127,36 @@ class SignerProvider {
             issueTokenAmount: (0, api_1.toApiNumber256Optional)(params.issueTokenAmount),
             gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
         };
-        return this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
+        return this.getNodeProvider().contracts.postContractsUnsignedTxDeployContract(data);
     }
     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 = {
             ...(await this.usePublicKey(params)),
             tokens: (0, api_1.toApiTokens)(params.tokens)
         };
-        return this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
+        return this.getNodeProvider().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 this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data);
-        return this.handleSign({
+        const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data);
+        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);
@@ -168,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.2.0-rc.32",
+  "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

@@ -29,20 +29,40 @@ function initializeNodeApi(baseUrl: string, apiKey?: string): NodeApi<string> {
   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) {
-    const nodeApi = initializeNodeApi(baseUrl, apiKey)
+interface 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']
+}
+
+export class NodeProvider 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(provider: INodeProvider)
+  constructor(baseUrl: string, apiKey?: string)
+  constructor(param0: string | INodeProvider, apiKey?: string) {
+    let nodeApi: INodeProvider
+    if (typeof param0 === 'string') {
+      nodeApi = initializeNodeApi(param0, apiKey)
+    } else {
+      nodeApi = param0 as INodeProvider
+    }
 
     this.wallets = nodeApi.wallets
     this.infos = nodeApi.infos
@@ -56,20 +76,42 @@ export class NodeProvider {
     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 can prevent the proxied node provider from being modified
+  static Proxy(nodeProvider: NodeProvider): NodeProvider {
+    return new NodeProvider(nodeProvider)
+  }
+}
 
-    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
+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 })
+        }
+      }
+    }
   }
 }