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

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

@@ -1,18 +1,31 @@
 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 declare class ExplorerProvider extends ExplorerApi<null> {
     constructor(baseUrl: string);

package/dist/src/api/index.js

@@ -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,19 +75,9 @@ 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;

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

@@ -90,18 +90,10 @@ export interface SignMessageParams {
 export interface SignMessageResult {
     signature: string;
 }
-export interface SignerProviderWithoutNodeProvider {
-    getSelectedAccount(): Promise<Account>;
-    signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
-    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 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>;
@@ -131,6 +123,13 @@ export declare abstract class SignerProviderWithMultipleAccounts extends SignerP
     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;

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.SignerProviderWrapper = exports.SignerProviderWithMultipleAccounts = exports.SignerProvider = void 0;
 const elliptic_1 = require("elliptic");
 const api_1 = require("../api");
 const utils = __importStar(require("../utils"));
@@ -63,9 +63,15 @@ const ec = new elliptic_1.ec('secp256k1');
 (0, utils_1.assertType)();
 (0, utils_1.assertType)();
 class SignerProvider {
+    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.nodeProvider.transactions.postTransactionsSubmit(params);
+        return this.getNodeProvider().transactions.postTransactionsSubmit(params);
     }
     async signAndSubmitTransferTx(params) {
         const signResult = await this.signTransferTx(params);
@@ -103,7 +109,7 @@ 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);
@@ -119,7 +125,7 @@ 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);
@@ -130,13 +136,13 @@ class SignerProvider {
             ...(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);
+        const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data);
         return this.handleSign({
             fromGroup: decoded.fromGroup,
             toGroup: decoded.toGroup,
@@ -182,6 +188,20 @@ 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.32",
+  "version": "0.2.0-rc.33",
   "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']
+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(baseUrl: string, apiKey?: string) {
-    const nodeApi = initializeNodeApi(baseUrl, apiKey)
+  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,9 @@ 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.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: NodeProvider): NodeProvider {
+    return new NodeProvider(nodeProvider)
   }
 }
 

package/src/signer/signer.ts

@@ -146,23 +146,20 @@ export interface SignMessageResult {
 }
 assertType<Eq<SignMessageResult, Pick<SignResult, 'signature'>>>()
 
-export interface SignerProviderWithoutNodeProvider {
-  getSelectedAccount(): Promise<Account>
-  signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
-  signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
-  signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  signHexString(params: SignHexStringParams): Promise<SignHexStringResult>
-  signMessage(params: SignMessageParams): Promise<SignMessageResult>
-}
-
-export abstract class SignerProvider implements SignerProviderWithoutNodeProvider {
-  abstract get nodeProvider(): NodeProvider
+export abstract class SignerProvider {
+  abstract get nodeProvider(): NodeProvider | undefined
   abstract getSelectedAccount(): Promise<Account>
 
+  private getNodeProvider(): NodeProvider {
+    if (this.nodeProvider === undefined) {
+      throw Error('The signer does not contain a node provider')
+    }
+    return this.nodeProvider
+  }
+
   async submitTransaction(unsignedTx: string, signature: string): Promise<SubmissionResult> {
     const params: node.SubmitTransaction = { unsignedTx: unsignedTx, signature: signature }
-    return this.nodeProvider.transactions.postTransactionsSubmit(params)
+    return this.getNodeProvider().transactions.postTransactionsSubmit(params)
   }
 
   async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SubmissionResult> {
@@ -205,7 +202,7 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
       destinations: toApiDestinations(params.destinations),
       gasPrice: toApiNumber256Optional(params.gasPrice)
     }
-    return this.nodeProvider.transactions.postTransactionsBuild(data)
+    return this.getNodeProvider().transactions.postTransactionsBuild(data)
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
@@ -223,7 +220,7 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
       issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
       gasPrice: toApiNumber256Optional(params.gasPrice)
     }
-    return this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
+    return this.getNodeProvider().contracts.postContractsUnsignedTxDeployContract(data)
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
@@ -236,14 +233,14 @@ export abstract class SignerProvider implements SignerProviderWithoutNodeProvide
       ...(await this.usePublicKey(params)),
       tokens: 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: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
     const data = { unsignedTx: params.unsignedTx }
-    const decoded = await this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data)
+    const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data)
     return this.handleSign({
       fromGroup: decoded.fromGroup,
       toGroup: decoded.toGroup,
@@ -303,6 +300,25 @@ export abstract class SignerProviderWithMultipleAccounts extends SignerProvider
   abstract setSelectedAccount(address: string): Promise<void>
 }
 
+export class SignerProviderWrapper extends SignerProvider {
+  signer: SignerProvider
+  nodeProvider: NodeProvider
+
+  constructor(signer: SignerProvider, nodeProvider: NodeProvider) {
+    super()
+    this.signer = signer
+    this.nodeProvider = nodeProvider
+  }
+
+  getSelectedAccount(): Promise<Account> {
+    return this.signer.getSelectedAccount()
+  }
+
+  signRaw(signerAddress: string, hexString: string): Promise<string> {
+    return this.signer.signRaw(signerAddress, hexString)
+  }
+}
+
 export interface SubmissionResult {
   txId: string
   fromGroup: number