def hash(self):
return poseidon([
int(self.publicKeyX),
int(self.publicKeyY),
int(self.nonce),
int(self._balancesTree._root)
], poseidonParamsAccount)
def hash(self):
#print("balance: " + self.balance)
temp = [
int(self.balance),
int(self.weightAMM),
int(self._storageTree._root)
]
#print(temp)
return poseidon(temp, poseidonParamsBalance)
def loopring_poseidon_hash(inputs):
# prepare params, using loopring order params
print(f"poseidon_hash {inputs}")
params = poseidon_params(SNARK_SCALAR_FIELD,
MAX_INPUT + 1,
6,
53,
b'poseidon',
5,
security_target=128)
hash_value = poseidon(inputs, params)
return hash_value
def _create_order(self, base_token, quote_token, buy, price, volume):
if buy:
tokenS = self.market_info_map[quote_token]
tokenB = self.market_info_map[base_token]
amountS = str(int(10 ** tokenS['decimals'] * price * volume))
amountB = str(int(10 ** tokenB['decimals'] * volume))
else:
tokenS = self.market_info_map[base_token]
tokenB = self.market_info_map[quote_token]
amountS = str(int(10 ** tokenS['decimals'] * volume))
amountB = str(int(10 ** tokenB['decimals'] * price * volume))
tokenSId = tokenS['tokenId']
tokenBId = tokenB['tokenId']
orderId = self.orderId[tokenSId]
assert orderId < self.MAX_ORDER_ID
self.orderId[tokenSId] += 1
# make valid time ahead 1 hour
validSince = int(time()) - self.time_offset - 3600
# order base
order = {
"exchangeId" : self.exchangeId,
"orderId" : orderId,
"accountId" : self.accountId,
"tokenSId" : tokenSId,
"tokenBId" : tokenBId,
"amountS" : amountS,
"amountB" : amountB,
"allOrNone" : "false",
"validSince" : validSince,
"validUntil" : validSince + 60 * 24 * 60 * 60,
"maxFeeBips" : 50,
"label" : 211,
"buy" : "true" if buy else "false",
"clientOrderId" : "SampleOrder" + str(int(time()*1000))
}
order_message = self._serialize_order(order)
msgHash = poseidon(order_message, self.order_sign_param)
signedMessage = PoseidonEdDSA.sign(msgHash, FQ(int(self.private_key)))
# update signaure
order.update({
"hash" : str(msgHash),
"signatureRx" : str(signedMessage.sig.R.x),
"signatureRy" : str(signedMessage.sig.R.y),
"signatureS" : str(signedMessage.sig.s)
})
return order
def _order(self, base_token, quote_token, buy, price, volume):
if buy:
tokenS = self.market_info_map[quote_token]
tokenB = self.market_info_map[base_token]
amountS = str(int(10 ** tokenS['decimals'] * price * volume))
amountB = str(int(10 ** tokenB['decimals'] * volume))
else:
tokenS = self.market_info_map[base_token]
tokenB = self.market_info_map[quote_token]
amountS = str(int(10 ** tokenS['decimals'] * volume))
amountB = str(int(10 ** tokenB['decimals'] * price * volume))
tokenSId = tokenS['tokenId']
tokenBId = tokenB['tokenId']
orderId = self.orderId[tokenSId]
assert orderId < self.MAX_ORDER_ID
self.orderId[tokenSId] += 1
# make valid time ahead 1 hour
validSince = int(time()) - self.time_offset - 3600
# order base
order = {
"exchangeId" : self.exchangeId,
"orderId" : orderId,
"accountId" : self.accountId,
"tokenSId" : tokenSId,
"tokenBId" : tokenBId,
"amountS" : amountS,
"amountB" : amountB,
"allOrNone" : "false",
"validSince" : validSince,
"validUntil" : validSince + 30 * 24 * 60 * 60,
"maxFeeBips" : 50,
"label" : 211,
"buy" : "true" if buy else "false",
"clientOrderId" : "SampleOrder" + str(int(time()))
}
order_message = self._serialize_order(order)
msgHash = poseidon(order_message, self.order_sign_param)
signedMessage = PoseidonEdDSA.sign(msgHash, FQ(int(self.private_key)))
# update signaure
order.update({
"hash" : str(msgHash),
"signatureRx" : str(signedMessage.sig.R.x),
"signatureRy" : str(signedMessage.sig.R.y),
"signatureS" : str(signedMessage.sig.s)
})
# print(f"create new order {order}")
data = {"security": Security.SIGNED}
self.add_request(
method="POST",
path="/api/v2/order",
callback=self.on_send_order,
params=order,
data=data,
extra=order
)
def hash(self):
return poseidon(
[int(self.filled),
int(self.cancelled),
int(self.orderID)], poseidonParamsTradingHistory)
def hash(self):
return poseidon(
[int(self.balance),
int(self._tradingHistoryTree._root)], poseidonParamsBalance)
def test_basic(self):
inputs = [1, 2]
python_result = poseidon(inputs)
evm_result = self.contract.functions.poseidon(inputs).call()
self.assertEqual(evm_result, python_result)
def hash(self):
return poseidon([int(self.data), int(self.storageID)], poseidonParamsStorage)
def hash(self, depth, inputs):
return poseidon(inputs, poseidonMerkleTreeParams)
def test_permutation(self):
self.assertEqual(poseidon([1,2]), 12242166908188651009877250812424843524687801523336557272219921456462821518061)
