trac-msb 0.2.8 → 0.2.9

package/src/core/network/protocols/V1Protocol.js

@@ -0,0 +1,64 @@
+import Protomux from 'protomux';
+import ProtocolInterface from './ProtocolInterface.js';
+import b4a from 'b4a';
+import c from 'compact-encoding';
+
+class V1Protocol extends ProtocolInterface {
+    #channel;
+    #session;
+    #config;
+    #router;
+
+    constructor(router, connection, config) {
+        super(router, connection, config);
+        this.#config = config;
+        this.#router = router;
+        this.init(connection);
+    }
+
+    get channel() {
+        return this.#channel;
+    }
+
+    get session() {
+        return this.#session;
+    }
+
+    init(connection) {
+        const mux = Protomux.from(connection);
+        connection.userData = mux;
+
+        this.#channel = mux.createChannel({
+            protocol: 'network/v1',
+            onopen() { },
+            onclose() { }
+        });
+
+        this.#channel.open();
+
+        this.#session = this.#channel.addMessage({
+            encoding: c.raw,
+            onmessage: async (incomingMessage) => {
+                try {
+                    if (b4a.isBuffer(incomingMessage)) {
+                        await this.#router.route(incomingMessage, connection, this.#session);
+                    } else {
+                        throw new Error('NetworkMessages: v1 message must be a buffer');
+                    }
+                } catch (error) {
+                    console.error(`NetworkMessages: Failed to handle incoming v1 message: ${error.message}`);
+                }
+            }
+        });
+    }
+
+    send(message) {
+        this.#session.send(message);
+    }
+
+    close() {
+        this.#channel.close();
+    }
+}
+
+export default V1Protocol;

package/src/core/network/protocols/legacy/NetworkMessageRouter.js

@@ -0,0 +1,84 @@
+import b4a from "b4a";
+import GetRequestHandler from "./handlers/GetRequestHandler.js";
+import ResponseHandler from "./handlers/ResponseHandler.js";
+import RoleOperationHandler from "../shared/handlers/RoleOperationHandler.js";
+import SubnetworkOperationHandler from "../shared/handlers/SubnetworkOperationHandler.js";
+import TransferOperationHandler from "../shared/handlers/TransferOperationHandler.js";
+import { NETWORK_MESSAGE_TYPES } from '../../../../utils/constants.js';
+import * as operation from '../../../../utils/applyOperations.js';
+import State from "../../../state/State.js";
+import PeerWallet from "trac-wallet";
+
+class NetworkMessageRouter {
+    #handlers;
+    #config;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiterService
+     * @param {TransactionPoolService} txPoolService
+     * @param {ConnectionManager} connectionManager
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiterService, txPoolService, connectionManager, config) {
+        this.#config = config;
+
+        this.#handlers = {
+            get: new GetRequestHandler(wallet, state),
+            response: new ResponseHandler(state, wallet, connectionManager, this.#config),
+            roleTransaction: new RoleOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            subNetworkTransaction: new SubnetworkOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+            tracNetworkTransaction: new TransferOperationHandler(state, wallet, rateLimiterService, txPoolService, this.#config),
+        }
+    }
+
+    // NOTE: messageProtomux can be deleted, ad this is a session, and we can extract this from connection
+    async route(incomingMessage, connection, messageProtomux) {
+        const channelString = b4a.toString(this.#config.channel, 'utf8');
+        if (this.#isGetRequest(incomingMessage)) {
+            await this.#handlers.get.handle(incomingMessage, messageProtomux, connection, channelString);
+        }
+        else if (this.#isResponse(incomingMessage)) {
+            await this.#handlers.response.handle(incomingMessage, connection, channelString);
+        }
+        else if (this.#isRoleAccessOperation(incomingMessage)) {
+            await this.#handlers.roleTransaction.handle(incomingMessage, connection);
+        }
+        else if (this.#isSubnetworkOperation(incomingMessage)) {
+            await this.#handlers.subNetworkTransaction.handle(incomingMessage, connection);
+        }
+        else if (this.#isTransferOperation(incomingMessage)) {
+            await this.#handlers.tracNetworkTransaction.handle(incomingMessage, connection);
+        }
+        else {
+            throw new Error(`Failed to route message. Pubkey of requester is ${connection.remotePublicKey ? b4a.toString(connection.remotePublicKey, 'hex') : 'unknown'}`);
+        }
+
+    }
+
+    #isGetRequest(message) {
+        return Object.values(NETWORK_MESSAGE_TYPES.GET).includes(message);
+    }
+
+
+    #isResponse(message) {
+        return Object.values(NETWORK_MESSAGE_TYPES.RESPONSE).includes(message.op);
+    }
+
+    #isRoleAccessOperation(message) {
+        return operation.isRoleAccess(message.type)
+    }
+
+    #isSubnetworkOperation(message) {
+        return operation.isTransaction(message.type) ||
+            operation.isBootstrapDeployment(message.type)
+    }
+
+    #isTransferOperation(message) {
+        return operation.isTransfer(message.type)
+    }
+}
+
+
+export default NetworkMessageRouter;

package/src/core/network/protocols/legacy/handlers/GetRequestHandler.js

@@ -0,0 +1,53 @@
+import { NETWORK_MESSAGE_TYPES } from '../../../../../utils/constants.js';
+import PeerWallet from 'trac-wallet';
+import b4a from 'b4a';
+
+class GetRequestHandler {
+    #wallet;
+    #state;
+
+    constructor(wallet, state) {
+        this.#wallet = wallet;
+        this.#state = state;
+    }
+
+    get state() {
+        return this.#state;
+    }
+
+    async handle(message, messageProtomux, connection, channelString) {
+        switch (message) {
+            case NETWORK_MESSAGE_TYPES.GET.VALIDATOR:
+                await this.handleGetValidatorResponse(messageProtomux, connection, channelString);
+                break;
+            default:
+                throw new Error(`Unhandled GET type: ${message}`);
+        }
+    }
+
+    async handleGetValidatorResponse(messageProtomux, connection, channelString) {
+        const nonce = PeerWallet.generateNonce().toString('hex');
+        const payload = {
+            op: 'validatorResponse',
+            wk: this.state.writingKey.toString('hex'),
+            address: this.#wallet.address,
+            nonce: nonce,
+            channel: channelString,
+            issuer: connection.remotePublicKey.toString('hex'),
+            timestamp: Date.now(),
+        };
+
+
+        const hashInput = b4a.from(JSON.stringify(payload), 'utf8');
+        const hash = await PeerWallet.blake3(hashInput);
+        const sig = this.#wallet.sign(hash);
+
+        const responseMessage = {
+            ...payload,
+            sig: sig.toString('hex'),
+        };
+        messageProtomux.send(responseMessage);
+    }
+}
+
+export default GetRequestHandler;

package/src/core/network/protocols/legacy/handlers/ResponseHandler.js

@@ -0,0 +1,37 @@
+import ValidatorResponse from '../validators/ValidatorResponse.js';
+import PeerWallet from 'trac-wallet';
+
+class ResponseHandler {
+    #responseValidator;
+    #connectionManager;
+
+    
+    constructor(state, wallet, connectionManager ,config) {
+        this.#responseValidator = new ValidatorResponse(state, wallet, config);
+        this.#connectionManager = connectionManager;
+
+    }
+
+    async handle(message, connection, channelString) {
+        await this.#handleValidatorResponse(message, connection, channelString);
+    }
+
+    async #handleValidatorResponse(message, connection, channelString) {
+        const isValid = await this.#responseValidator.validate(message, channelString);
+        if (isValid) {
+            const validatorAddressString = message.address;
+            const validatorPublicKey = PeerWallet.decodeBech32m(validatorAddressString);
+
+            if (this.#connectionManager.connected(validatorPublicKey)) {
+                return;
+                // TODO: What we should return? Or maybe we should throw?
+            }
+
+            this.#connectionManager.addValidator(validatorPublicKey, connection)
+        } else {
+            throw new Error("Validator response verification failed");
+        }
+    }
+}
+
+export default ResponseHandler;

package/src/core/network/{messaging → protocols/legacy}/validators/base/BaseResponse.js

@@ -1,7 +1,6 @@
 import b4a from 'b4a';
 import PeerWallet from 'trac-wallet';
-import { bufferToAddress } from '../../../../state/utils/address.js';
-import State from '../../../../state/State.js';
+import State from '../../../../../state/State.js';
 
 /*
     BaseResponse class for handling common validation logic for network responses.

package/src/core/network/protocols/shared/handlers/RoleOperationHandler.js

@@ -0,0 +1,88 @@
+import {OperationType} from '../../../../../utils/constants.js';
+import PartialRoleAccess from "../validators/PartialRoleAccess.js";
+import BaseOperationHandler from './base/BaseOperationHandler.js';
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import {normalizeRoleAccessOperation} from "../../../../../utils/normalizers.js";
+
+class RoleOperationHandler extends BaseOperationHandler {
+    #partialRoleAccessValidator;
+    #wallet;
+    #config;
+    #txPoolService;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
+     * @param {object} config
+     **/
+    constructor(state, wallet, rateLimiter, txPoolService ,config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
+        this.#wallet = wallet;
+        this.#config = config;
+        this.#partialRoleAccessValidator = new PartialRoleAccess(state, this.#wallet.address ,this.#config)
+        this.#txPoolService = txPoolService;
+    }
+
+    get partialRoleAccessValidator() {
+        return this.#partialRoleAccessValidator;
+    }
+
+    async handleOperation(message, connection) {
+        const normalizedPartialRoleAccessPayload = normalizeRoleAccessOperation(message, this.#config)
+        const isValid = await this.partialRoleAccessValidator.validate(normalizedPartialRoleAccessPayload)
+        let completePayload = null
+        if (!isValid) {
+            throw new Error("OperationHandler: partial role access payload validation failed.");
+        }
+        
+        switch (normalizedPartialRoleAccessPayload.type) {
+            case OperationType.ADD_WRITER:
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteAddWriterMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            case OperationType.REMOVE_WRITER:
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteRemoveWriterMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            case OperationType.ADMIN_RECOVERY:
+
+                completePayload = await applyStateMessageFactory(this.#wallet, this.#config)
+                    .buildCompleteAdminRecoveryMessage(
+                        normalizedPartialRoleAccessPayload.address,
+                        normalizedPartialRoleAccessPayload.rao.tx,
+                        normalizedPartialRoleAccessPayload.rao.txv,
+                        normalizedPartialRoleAccessPayload.rao.iw,
+                        normalizedPartialRoleAccessPayload.rao.in,
+                        normalizedPartialRoleAccessPayload.rao.is,
+                    )
+                break;
+            default:
+                throw new Error("OperationHandler: Assembling complete role access operation failed due to unsupported operation type.");
+        }
+
+        if (!completePayload) {
+            throw new Error("OperationHandler: Assembling complete role access operation failed.");
+        }
+
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completePayload))
+    }
+}
+
+export default RoleOperationHandler;

package/src/core/network/protocols/shared/handlers/SubnetworkOperationHandler.js

@@ -0,0 +1,93 @@
+import BaseOperationHandler from './base/BaseOperationHandler.js';
+import {
+    OperationType
+} from '../../../../../utils/constants.js';
+import PartialBootstrapDeployment from "../validators/PartialBootstrapDeployment.js";
+import PartialTransaction from "../validators/PartialTransaction.js";
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import {
+    normalizeBootstrapDeploymentOperation,
+    normalizeTransactionOperation
+} from "../../../../../utils/normalizers.js";
+
+
+class SubnetworkOperationHandler extends BaseOperationHandler {
+    #partialBootstrapDeploymentValidator;
+    #partialTransactionValidator;
+    #config;
+    #wallet;
+    #txPoolService;
+
+    /**
+     * @param {State} state
+     * @param {PeerWallet} wallet
+     * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
+     * @param {object} config
+     **/
+    constructor( state, wallet, rateLimiter, txPoolService, config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
+        this.#config = config;
+        this.#wallet = wallet
+        this.#partialBootstrapDeploymentValidator = new PartialBootstrapDeployment(state, this.#wallet.address, config);
+        this.#partialTransactionValidator = new PartialTransaction(state, this.#wallet.address, config);
+        this.#txPoolService = txPoolService;
+    }
+
+    async handleOperation(payload, connection)  {
+        if (payload.type === OperationType.TX) {
+            await this.#partialTransactionSubHandler(payload, connection);
+        } else if (payload.type === OperationType.BOOTSTRAP_DEPLOYMENT) {
+            await this.#partialBootstrapDeploymentSubHandler(payload, connection);
+        } else {
+            throw new Error('Unsupported operation type for SubnetworkOperationHandler');
+        }
+    }
+
+    async #partialTransactionSubHandler(payload, connection) {
+        const normalizedPayload = normalizeTransactionOperation(payload, this.#config);
+        const isValid = await this.#partialTransactionValidator.validate(normalizedPayload);
+        if (!isValid) {
+            throw new Error("SubnetworkHandler: Transaction validation failed.");
+        }
+
+        const completeTransactionOperation = await applyStateMessageFactory(this.#wallet,this.#config)
+            .buildCompleteTransactionOperationMessage(
+                normalizedPayload.address,
+                normalizedPayload.txo.tx,
+                normalizedPayload.txo.txv,
+                normalizedPayload.txo.iw,
+                normalizedPayload.txo.in,
+                normalizedPayload.txo.ch,
+                normalizedPayload.txo.is,
+                normalizedPayload.txo.bs,
+                normalizedPayload.txo.mbs
+            )
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransactionOperation));
+    }
+
+    async #partialBootstrapDeploymentSubHandler(payload, connection) {
+        const normalizedPayload = normalizeBootstrapDeploymentOperation(payload, this.#config);
+        const isValid = await this.#partialBootstrapDeploymentValidator.validate(normalizedPayload);
+        if (!isValid) {
+            throw new Error("SubnetworkHandler: Bootstrap deployment validation failed.");
+        }
+
+
+        const completeBootstrapDeploymentOperation = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteBootstrapDeploymentMessage(
+                normalizedPayload.address,
+                normalizedPayload.bdo.tx,
+                normalizedPayload.bdo.txv,
+                normalizedPayload.bdo.bs,
+                normalizedPayload.bdo.ic,
+                normalizedPayload.bdo.in,
+                normalizedPayload.bdo.is
+            )
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeBootstrapDeploymentOperation));
+
+    }
+}
+
+export default SubnetworkOperationHandler;

package/src/core/network/{messaging → protocols/shared}/handlers/TransferOperationHandler.js

@@ -1,45 +1,46 @@
 import BaseOperationHandler from './base/BaseOperationHandler.js';
-import CompleteStateMessageOperations
-    from "../../../../messages/completeStateMessages/CompleteStateMessageOperations.js";
-import {OperationType} from '../../../../utils/constants.js';
+import {OperationType} from '../../../../../utils/constants.js';
 import PartialTransfer from "../validators/PartialTransfer.js";
-import {normalizeTransferOperation} from "../../../../utils/normalizers.js"
+import {normalizeTransferOperation} from "../../../../../utils/normalizers.js"
+import {applyStateMessageFactory} from "../../../../../messages/state/applyStateMessageFactory.js";
+import {safeEncodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
 
 class TransferOperationHandler extends BaseOperationHandler {
     #partialTransferValidator;
     #config;
     #wallet;
+    #txPoolService;
 
     /**
-     * @param {Network} network
      * @param {State} state
      * @param {PeerWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
      * @param {object} config
      **/
-    constructor(network, state, wallet, rateLimiter, config) {
-        super(network, state, wallet, rateLimiter, config);
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
+        super(state, wallet, rateLimiter, txPoolService, config);
         this.#config = config;
         this.#wallet = wallet;
-        this.#partialTransferValidator = new PartialTransfer(state, wallet, this.#config);
+        this.#partialTransferValidator = new PartialTransfer(state, this.#wallet.address, this.#config);
+        this.#txPoolService = txPoolService;
     }
 
-    async handleOperation(payload) {
+    async handleOperation(payload, connection) {
         if (payload.type !== OperationType.TRANSFER) {
             throw new Error('Unsupported operation type for TransferOperationHandler');
         }
-        await this.#handleTransfer(payload);
+        await this.#handleTransfer(payload, connection);
     }
 
-    async #handleTransfer(payload) {
+    async #handleTransfer(payload, connection) {
         const normalizedPayload = normalizeTransferOperation(payload, this.#config);
         const isValid = await this.#partialTransferValidator.validate(normalizedPayload);
         if (!isValid) {
             throw new Error("TransferHandler: Transfer validation failed.");
         }
 
-        const completeTransferOperation = await new CompleteStateMessageOperations(this.#wallet, this.#config)
-            .assembleCompleteTransferOperationMessage(
+        const completeTransferOperation = await applyStateMessageFactory(this.#wallet, this.#config)
+            .buildCompleteTransferOperationMessage(
                 normalizedPayload.address,
                 normalizedPayload.tro.tx,
                 normalizedPayload.tro.txv,
@@ -47,9 +48,9 @@ class TransferOperationHandler extends BaseOperationHandler {
                 normalizedPayload.tro.to,
                 normalizedPayload.tro.am,
                 normalizedPayload.tro.is
-            );
+            )
 
-        this.network.transactionPoolService.addTransaction(completeTransferOperation);
+        this.#txPoolService.addTransaction(safeEncodeApplyOperation(completeTransferOperation));
     }
 }
 

package/src/core/network/{messaging → protocols/shared}/handlers/base/BaseOperationHandler.js

@@ -1,35 +1,31 @@
 import b4a from 'b4a';
-import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE} from '../../../../../utils/constants.js';
+import {MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, TRANSACTION_POOL_SIZE} from '../../../../../../utils/constants.js';
 
 class BaseOperationHandler {
-    #network;
     #state;
     #wallet;
     #rateLimiter;
+    #txPoolService;
     #config;
 
     /**
-     * @param {Network} network
      * @param {State} state
      * @param {PeerWallet} wallet
      * @param {TransactionRateLimiterService} rateLimiter
+     * @param {TransactionPoolService} txPoolService
      * @param {object} config
      **/
-    constructor(network, state, wallet, rateLimiter, config) {
+    constructor(state, wallet, rateLimiter, txPoolService, config) {
         if (new.target === BaseOperationHandler) {
             throw new Error('BaseOperationHandler is abstract and cannot be instantiated directly');
         }
-        this.#network = network;
         this.#state = state;
         this.#wallet = wallet;
         this.#rateLimiter = rateLimiter;
+        this.#txPoolService = txPoolService;
         this.#config = config;
     }
 
-    get network() {
-        return this.#network;
-    }
-
     async validateBasicRequirements(payload, connection) {
         // Validate if operation can be processed:
         // - Non-writable nodes cannot process operations
@@ -42,7 +38,7 @@ class BaseOperationHandler {
             throw new Error('OperationHandler: State is not writable or is an indexer without admin privileges.');
         }
 
-        if (this.#network.transactionPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
+        if (this.#txPoolService.tx_pool.length >= TRANSACTION_POOL_SIZE) {
             throw new Error("OperationHandler: Transaction pool is full, ignoring incoming transaction.");
         }
 
@@ -51,7 +47,7 @@ class BaseOperationHandler {
         }
         
         if (!this.#config.disableRateLimit) {
-            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection, this.#network);
+            const shouldDisconnect = this.#rateLimiter.handleRateLimit(connection);
             if (shouldDisconnect) {
                 throw new Error(`OperationHandler: Rate limit exceeded for peer ${b4a.toString(connection.remotePublicKey, 'hex')}. Disconnecting...`);
             }

package/src/core/network/{messaging → protocols/shared}/validators/PartialBootstrapDeployment.js

@@ -1,8 +1,8 @@
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialBootstrapDeployment extends PartialOperation {
-    constructor(state, wallet , config) {
-        super(state, wallet , config);
+    constructor(state, selfAddress , config) {
+        super(state, selfAddress , config);
     }
 
     async validate(payload) {

package/src/core/network/{messaging → protocols/shared}/validators/PartialRoleAccess.js

@@ -1,14 +1,14 @@
 import b4a from 'b4a';
-import {OperationType} from "../../../../utils/constants.js";
-import {bufferToAddress} from "../../../state/utils/address.js";
+import {OperationType} from "../../../../../utils/constants.js";
+import {bufferToAddress} from "../../../../state/utils/address.js";
 import PartialOperation from './base/PartialOperation.js';
-import {bufferToBigInt} from "../../../../utils/amountSerialization.js";
+import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
 
 class PartialRoleAccess extends PartialOperation {
     #config;
 
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
         this.#config = config
     }
 

package/src/core/network/{messaging → protocols/shared}/validators/PartialTransaction.js

@@ -1,13 +1,13 @@
 import b4a from 'b4a';
-import {safeDecodeApplyOperation} from "../../../../utils/protobuf/operationHelpers.js";
-import deploymentEntryUtils from "../../../state/utils/deploymentEntry.js";
+import {safeDecodeApplyOperation} from "../../../../../utils/protobuf/operationHelpers.js";
+import deploymentEntryUtils from "../../../../state/utils/deploymentEntry.js";
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialTransaction extends PartialOperation {
     #config
 
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
         this.#config = config
     }
 

package/src/core/network/{messaging → protocols/shared}/validators/PartialTransfer.js

@@ -1,14 +1,14 @@
 import PeerWallet from 'trac-wallet';
 
-import {bufferToAddress} from "../../../state/utils/address.js";
-import {bufferToBigInt} from "../../../../utils/amountSerialization.js";
+import {bufferToAddress} from "../../../../state/utils/address.js";
+import {bufferToBigInt} from "../../../../../utils/amountSerialization.js";
 import PartialOperation from './base/PartialOperation.js';
 
 class PartialTransfer extends PartialOperation {
     #config
 
-    constructor(state, wallet, config) {
-        super(state, wallet, config);
+    constructor(state, selfAddress, config) {
+        super(state, selfAddress, config);
         this.#config = config
     }