Self Recharging Wallets

Types of Wallets

There are several types of wallets in the SKALE Network. These include:

1. Wallets Controlled by the validator, node operator, and SKALE Chain owner. These wallets may be software or hardware wallets.
2. Self-Recharging wallets can be for validators and for the SKALE Chain owner.

Node Transactions & Reimbursement

The following table explores what node transactions are reimbursed and by who.

Transaction	Reimbursed By	Description of Transaction
getBounty()	Validator	Called every month by each node to request bounty.
nodeExit()	Validator	To remove a node from the network due to hardware failure or unmet MSR.
complaint()	Validator	Performed in DKG failure mode when a node lodges a general DKG complaint against a malicious node who may have failed to send data.
complaintBadData()	Validator	Performed in DKG failure mode when a node discovers that malicious data has been sent and requires verification data to validate.
preResponse()	Validator	Performed in DKG failure mode, when a node sends a verification vector and secret key shares ahead of the final response() result.
response()	Validator	Performed in DKG failure mode when a node sends a response to a complaint() to prove it’s not malicious based on the data it sends in preResponse().
broadcast()	SKALE Chain Owner	Performed during SKALE Chain creation when distributed key generation process begins. Nodes broadcast their secret key contributions to all other nodes.
alright()	SKALE Chain Owner	Performed during SKALE Chain creation when distributed key generation is in-process. Nodes send receipts of secret key contributions.

Replenishment

Self-recharging validator wallets can be replenished in ETH by anyone with the wallet’s contract address and the ValidatorId or sChainId. This functionality allows anyone to ensure the continued ETH funding and operation of validator nodes and SKALE Chains.

If the self-recharging…

• validator balance runs out of ETH, then the nodes’ wallets are first spent until transactions revert.
• SKALE Chain Owner balance runs out of ETH, then transactions will revert.

Node wallets connected to the self-recharging validator wallet are replenished automatically at the end of each transaction based on the best estimate of the gas consumed in the transaction.

Caution

If the validator self-recharging wallet is out of ETH, then node wallets start using their own ETH until the node balance is 0. Suppose the validator self-recharging wallet has 0 balance at the same time that the node wallet balance is 0. In that case, validators are then responsible for recharging both the validator self-recharging wallet and the node wallets with 0 balance.

Danger

If a node’s getBounty transaction reverts and can’t complete the transaction before the end of the month, the validator-delegators will receive less bounty. Validators must ensure sufficient balance and a working endpoint to connect with Ethereum mainnet.

Note

There is no easy way to know the EVM’s refund counter’s value from inside the EVM. Thus, refunds may offset the transaction’s final net cost, and node balances may slightly increase over time. This process will be reviewed and improved over time.

Using a Self-Recharging Wallet

When a new validator is registered, a self-recharging wallet is automatically deployed. The validator’s private key has withdraw access to this wallet. Validators can use this private key to close the self-recharging wallet should the validator leave the network.

As a validator links nodes to their validator ID, these linked nodes will automatically request reimbursement from the validator’s self-recharging wallet for those transactions. If a node is unlinked from the validator, this node will no longer request reimbursement from the validator’s self-recharging wallet.

Existing validators will automatically be added to the Wallet contract and will start using them once this feature is deployed to mainnet.

Interacting with the Self-Recharging Wallet (SRW)

Validators can use the CLI to recharge, withdraw funds from, or check the self-recharging wallet’s balance. Anyone can recharge or check the balance by interacting with the Wallet contract on Ethereum.

For the CLI

# Validator recharges the self-recharging wallet from their wallet (sk-val wallet info)
sk-val srw recharge AMOUNT_IN_ETH [--validator-id VALIDATOR_ID] [--gas-price PRICE_IN_GWEI] [--pk-file PATH_TO_PK]

> sk-val srw recharge 0.1                                  # Recharge using a hardware wallet
> sk-val srw recharge 0.1 --validator-id 1                 # Recharge validator ID 1 using a hardware wallet
> sk-val srw recharge 0.1 --pk-file ./tests/test-pk.txt    # Recharge using a software wallet

# Validator withdraws an amount from the self-recharging wallet
sk-val srw withdraw AMOUNT_IN_ETH [--pk-file PATH_TO_PK] [--gas-price PRICE_IN_GWEI]

> sk-val srw withdraw 0.1                                  # Withdraw using a hardware wallet
> sk-val srw withdraw 0.1 --pk-file ./tests/test-pk.txt    # Withdraw using a software wallet

# Returns self-recharging wallet balance
sk-val srw balance VALIDATOR_ID [--wei]

> sk-val srw balance 1          # Show balance in ETH
> sk-val srw balance 1 --wei    # Show balance in Wei

For Wallets Contract

See https://github.com/skalenetwork/skale-manager/blob/develop/contracts/Wallets.sol

rechargeValidatorWallet(validatorId)
withdrawFundsFromValidatorWallet(amount)
getValidatorBalance(validatorId)