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

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/api/types.d.ts

@@ -1,5 +1,5 @@
 import * as node from './api-alephium';
-export declare type Number256 = number | bigint | string;
+export declare type Number256 = bigint;
 export declare type Val = Number256 | boolean | string | Val[];
 export declare type NamedVals = Record<string, Val>;
 export interface Token {
@@ -13,7 +13,7 @@ export declare function fromApiTokens(tokens?: node.Token[]): Token[] | undefine
 export declare function toApiBoolean(v: Val): boolean;
 export declare function toApiNumber256(v: Val): string;
 export declare function toApiNumber256Optional(v?: Val): string | undefined;
-export declare function fromApiNumber256(n: string): Number256;
+export declare function fromApiNumber256(n: string): bigint;
 export declare function toApiByteVec(v: Val): string;
 export declare function toApiAddress(v: Val): string;
 export declare function toApiArray(tpe: string, v: Val): node.Val;

package/dist/src/api/types.js

@@ -63,12 +63,7 @@ function toApiNumber256Optional(v) {
 }
 exports.toApiNumber256Optional = toApiNumber256Optional;
 function fromApiNumber256(n) {
-    if (Number.isSafeInteger(Number.parseInt(n))) {
-        return Number(n);
-    }
-    else {
-        return BigInt(n);
-    }
+    return BigInt(n);
 }
 exports.fromApiNumber256 = fromApiNumber256;
 // TODO: check hex string

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 {
@@ -213,7 +213,7 @@ export interface DeployContractTransaction {
 export interface BuildDeployContractTx {
     signerAddress: string;
     initialFields?: Fields;
-    initialAttoAlphAmount?: string;
+    initialAttoAlphAmount?: Number256;
     initialTokenAmounts?: Token[];
     issueTokenAmount?: Number256;
     gasAmount?: number;

package/dist/src/contract/contract.js

@@ -582,26 +582,22 @@ 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),
-            initialTokenAmounts: (0, api_1.toApiTokens)(params.initialTokenAmounts),
+            initialAttoAlphAmount: params.initialAttoAlphAmount,
+            issueTokenAmount: params.issueTokenAmount,
+            initialTokenAmounts: params.initialTokenAmounts,
             gasAmount: params.gasAmount,
-            gasPrice: extractOptionalNumber256(params.gasPrice)
+            gasPrice: params.gasPrice
         };
         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,32 +648,26 @@ 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),
+            attoAlphAmount: params.attoAlphAmount,
+            tokens: params.tokens,
             gasAmount: params.gasAmount,
-            gasPrice: extractOptionalNumber256(params.gasPrice)
+            gasPrice: params.gasPrice
         };
         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);
     }
 }
 exports.Script = Script;
-function extractOptionalNumber256(v) {
-    return typeof v !== 'undefined' ? (0, api_1.toApiNumber256)(v) : undefined;
-}
 function fromApiFields(vals, fieldsSig) {
     return (0, api_1.fromApiVals)(vals, fieldsSig.names, fieldsSig.types);
 }
@@ -758,8 +748,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,14 +42,16 @@ export interface SignDeployContractTxResult {
     signature: string;
     contractId: string;
     contractAddress: string;
+    gasAmount: number;
+    gasPrice: Number256;
 }
 export interface SignExecuteScriptTxParams {
     signerAddress: string;
     bytecode: string;
-    attoAlphAmount?: string;
+    attoAlphAmount?: Number256;
     tokens?: Token[];
     gasAmount?: number;
-    gasPrice?: string;
+    gasPrice?: Number256;
 }
 export interface SignExecuteScriptTxResult {
     fromGroup: number;
@@ -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,12 +131,15 @@ 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 = {
             ...(await this.usePublicKey(params)),
-            tokens: (0, api_1.toApiTokens)(params.tokens)
+            attoAlphAmount: (0, api_1.toApiNumber256Optional)(params.attoAlphAmount),
+            tokens: (0, api_1.toApiTokens)(params.tokens),
+            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
         };
         return this.getNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data);
     }
@@ -143,30 +148,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 +166,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 +180,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.35",
   "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/api/types.ts

@@ -19,7 +19,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import { assertType, bs58, Eq } from '../utils'
 import * as node from './api-alephium'
 
-export type Number256 = number | bigint | string
+export type Number256 = bigint
 export type Val = Number256 | boolean | string | Val[]
 export type NamedVals = Record<string, Val>
 
@@ -68,12 +68,8 @@ export function toApiNumber256Optional(v?: Val): string | undefined {
   return v === undefined ? undefined : toApiNumber256(v)
 }
 
-export function fromApiNumber256(n: string): Number256 {
-  if (Number.isSafeInteger(Number.parseInt(n))) {
-    return Number(n)
-  } else {
-    return BigInt(n)
-  }
+export function fromApiNumber256(n: string): bigint {
+  return BigInt(n)
 }
 
 // TODO: check hex string