MultiAccount
In order to place trades using a SYMM frontend solution or otherwise, it's necessary to create a sub-account using a MultiAccount contract that is whitelisted to interact with the hedger. Users are required to provide a name as an input parameter when they create a sub-account. All positions on a sub-account are in CROSS, but positions between sub-accounts are ISOLATED.
MultiAccount Contract Functions
Initialization and Setup
initialize()
Initializes the MultiAccount contract with roles and addresses necessary for operation.
function initialize(address admin, address symmioAddress_, bytes memory accountImplementation_) public initializer {
__Pausable_init();
__AccessControl_init();
_grantRole(DEFAULT_ADMIN_ROLE, admin);
_grantRole(PAUSER_ROLE, admin);
_grantRole(UNPAUSER_ROLE, admin);
_grantRole(SETTER_ROLE, admin);
accountsAdmin = admin;
symmioAddress = symmioAddress_;
accountImplementation = accountImplementation_;
}
Parameters:
admin: The administrator's address who will have default and control roles.symmioAddress_: Address of the Symmio platform to interact with.accountImplementation_: Bytecode for the account implementation to be used (SymmioPartyA).
Account Management
addAccount()
Creates a new sub-account for a user with a specified name.
function addAccount(string memory name) external whenNotPaused {
address account = _deployPartyA();
indexOfAccount[account] = accounts[msg.sender].length;
accounts[msg.sender].push(Account(account, name));
owners[account] = msg.sender;
emit AddAccount(msg.sender, account, name);
}Parameters:
name: Name of the sub-account.
Emits: AddAccount event upon successful creation.
editAccountName()
Allows the owner to change the name of an existing sub-account.
function editAccountName(address accountAddress, string memory name) external whenNotPaused {
uint256 index = indexOfAccount[accountAddress];
accounts[msg.sender][index].name = name;
emit EditAccountName(msg.sender, accountAddress, name);
}Parameters:
accountAddress: Address of the account to rename.name: New name for the account.
Emits: EditAccountName event.
depositForAccount()
Deposits funds into a sub-account from the owner's balance.
function depositForAccount(address account, uint256 amount) external onlyOwner(account, msg.sender) whenNotPaused {
address collateral = ISymmio(symmioAddress).getCollateral();
IERC20Upgradeable(collateral).safeTransferFrom(msg.sender, address(this), amount);
IERC20Upgradeable(collateral).safeApprove(symmioAddress, amount);
ISymmio(symmioAddress).depositFor(account, amount);
emit DepositForAccount(msg.sender, account, amount);
}Parameters:
account: Address of the sub-account.amount: Amount to deposit.
Emits: DepositForAccount event.
depositAndAllocateForAccount()
Deposits funds into a sub-account and allocates them for trading.
function depositAndAllocateForAccount(address account, uint256 amount) external onlyOwner(account, msg.sender) whenNotPaused {
address collateral = ISymmio(symmioAddress).getCollateral();
IERC20Upgradeable(collateral).safeTransferFrom(msg.sender, address(this), amount);
IERC20Upgradeable(collateral).safeApprove(symmioAddress, amount);
ISymmio(symmioAddress).depositFor(account, amount);
uint256 amountWith18Decimals = (amount * 1e18) / (10 ** IERC20Metadata(collateral).decimals());
bytes memory _callData = abi.encodeWithSignature("allocate(uint256)", amountWith18Decimals);
innerCall(account, _callData);
emit DepositForAccount(msg.sender, account, amount);
emit AllocateForAccount(msg.sender, account, amountWith18Decimals);
}Parameters:
account: Address of the sub-account.amount: Amount to deposit and allocate.
Emits: DepositForAccount and AllocateForAccount events.
withdrawFromAccount()
Withdraws funds from a sub-account back to the owner's address.
function withdrawFromAccount(address account, uint256 amount) external onlyOwner(account, msg.sender) whenNotPaused {
bytes memory _callData = abi.encodeWithSignature("withdrawTo(address,uint256)", owners[account], amount);
emit WithdrawFromAccount(msg.sender, account, amount);
innerCall(account, _callData);
}Parameters:
account: Address of the sub-account.amount: Amount to withdraw.
Emits: WithdrawFromAccount event.
Access Control
delegateAccess()
Allows the owner of a sub-account to delegate control over specific functions to another address.
function delegateAccess(address account, address target, bytes4 selector, bool state) external onlyOwner(account, msg.sender) {
require(target != msg.sender && target != account, "MultiAccount: invalid target");
emit DelegateAccess(account, target, selector, state);
delegatedAccesses[account][target][selector] = state;
}Parameters:
account: Address of the sub-account.target: Address to which access is delegated.selector: Function selector for which access is granted.state: Boolean to enable or disable access.truesets the delegation state to enabled, allowing the delegate to call the specified function on behalf of the sub-account
Emits: DelegateAccess event.
delegateAccesses()
Batch version of delegateAccess for multiple function selectors.
function delegateAccesses(address account, address target, bytes4[] memory selector, bool state) external onlyOwner(account, msg.sender) {
require(target != msg.sender && target != account, "MultiAccount: invalid target");
for (uint256 i = selector.length; i != 0; i--) {
delegatedAccesses[account][target][selector[i - 1]] = state;
emit DelegateAccess(account, target, selector[i - 1], state);
}
}Parameters:
account,target,selector[], andstateas indelegateAccess.
Emits: DelegateAccess event for each selector.
Configuration and Address Management
setAccountImplementation()
Sets new account implementation bytecode.
function setAccountImplementation(bytes memory accountImplementation_) external onlyRole(SETTER_ROLE) {
emit SetAccountImplementation(accountImplementation, accountImplementation_);
accountImplementation = accountImplementation_;
}Parameters:
accountImplementation_: New bytecode for account implementation.
Emits: SetAccountImplementation event.
setSymmioAddress()
Updates the address of the Symmio platform.
function setSymmioAddress(address addr) external onlyRole(SETTER_ROLE) {
emit SetSymmioAddress(symmioAddress, addr);
symmioAddress = addr;
}Parameters:
addr: New address for the Symmio platform.
Emits: SetSymmioAddress event.
Pausable Functionality
pause()
Pauses all pausable actions in the contract, preventing execution. Only callable by addresses with the PAUSER_ROLE.
function pause() external onlyRole(PAUSER_ROLE) {
_pause();
}unpause()
Resumes all actions in the contract after being paused. Only callable by addresses with the UNPAUSER_ROLE.
function unpause() external onlyRole(UNPAUSER_ROLE) {
_unpause();
}Internal and Utility Functions
_deployPartyA()
Deploys a new sub-account using the current account implementation.
function _deployPartyA() internal returns (address account) {
bytes32 salt = keccak256(abi.encodePacked("MultiAccount_", saltCounter));
saltCounter += 1;
bytes memory bytecode = abi.encodePacked(accountImplementation, abi.encode(accountsAdmin, address(this), symmioAddress));
account = _deployContract(bytecode, salt);
return account;
}Returns: Address of the newly deployed account.
_deployContract()
Internal function to deploy contracts using the create2 opcode.
function _deployContract(bytes memory bytecode, bytes32 salt) internal returns (address contractAddress) {
assembly {
contractAddress := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
require(contractAddress != address(0), "MultiAccount: create2 failed");
emit DeployContract(msg.sender, contractAddress);
return contractAddress;
}Parameters:
bytecode: Compiled bytecode of the contract.salt: Salt used for create2 to determine the address.
Returns: Address of the deployed contract.
_call()
Internal function to invoke methods on other contracts.
function _call(address account, bytes[] memory _callDatas) public whenNotPaused {
bool isOwner = owners[account] == msg.sender;
for (uint8 i; i < _callDatas.length; i++) {
bytes memory _callData = _callDatas[i];
if (!isOwner) {
require(_callData.length >= 4, "MultiAccount: Invalid call data");
bytes4 functionSelector;
assembly {
functionSelector := mload(add(_callData, 0x20))
}
require(delegatedAccesses[account][msg.sender][functionSelector], "MultiAccount: Unauthorized access");
}
innerCall(account, _callData);
}
}Parameters:
account: Account from which the call is made._callDatas[]: Array of call data to be executed.
Executes multiple calls in a single transaction if authorized.
View Functions
getAccountsLength()
Returns the number of accounts owned by a user.
function getAccountsLength(address user) external view returns (uint256) {
return accounts[user].length;
}Parameters:
user: Address of the user.
Returns: Number of accounts.
getAccounts()
Retrieves a list of sub-accounts owned by a user.
function getAccounts(address user, uint256 start, uint256 size) external view returns (Account[] memory) {
uint256 len = size > accounts[user].length - start ? accounts[user].length - start : size;
Account[] memory userAccounts = new Account[](len);
for (uint256 i = start; i < start + len; i++) {
userAccounts[i - start] = accounts[user][i];
}
return userAccounts;
}Parameters:
user: Owner's address.start: Start index for pagination.size: Number of accounts to return.
Returns: Array of Account structs.
Last updated