def breakGlass(self, newContracts):
sp.set_type(
newContracts,
sp.TRecord(
governorContract=sp.TAddress,
tokenContract=sp.TAddress,
ovenProxyContract=sp.TAddress,
stabilityFundContract=sp.TAddress,
developerFundContract=sp.TAddress,
).layout(("governorContract", ("tokenContract",
("ovenProxyContract",
("stabilityFundContract",
"developerFundContract"))))))
# Can only be called by the multisig.
sp.verify(sp.sender == self.data.multisigAddress, "NOT_MSIG")
targetParam = (newContracts.governorContract,
(newContracts.tokenContract,
(newContracts.ovenProxyContract,
(newContracts.stabilityFundContract,
newContracts.developerFundContract))))
targetContractHandle = sp.contract(
sp.TPair(
sp.TAddress,
sp.TPair(
sp.TAddress,
sp.TPair(sp.TAddress, sp.TPair(sp.TAddress,
sp.TAddress)))),
self.data.targetAddress, 'updateContracts').open_some()
sp.transfer(targetParam, sp.mutez(0), targetContractHandle)
def __init__(self, admin):
with open('metadata/metadata.json', 'r') as f:
#loads then dumps to confirm correctly formatted json
metadata = json.dumps(json.load(f))
self.init(
paused=False,
balances=sp.big_map(tvalue=sp.TRecord(
approvals=sp.TMap(sp.TAddress, sp.TNat), balance=sp.TNat)),
administrator=admin,
totalSupply=0,
permits=sp.big_map(tkey=sp.TPair(sp.TAddress, sp.TBytes),
tvalue=sp.TTimestamp),
user_expiries=sp.big_map(tkey=sp.TAddress,
tvalue=sp.TOption(sp.TNat)),
permit_expiries=sp.big_map(tkey=sp.TPair(
sp.TAddress, sp.TBytes),
tvalue=sp.TOption(sp.TNat)),
counter=0,
default_expiry=50000,
max_expiry=2628000,
metadata=sp.big_map(
l={
"": sp.bytes_of_string("tezos-storage:md-json"),
"md-json": sp.bytes_of_string(metadata)
}))
def permit(self, params):
sp.set_type(
params,
sp.TList(sp.TPair(sp.TKey, sp.TPair(sp.TSignature, sp.TBytes))))
sp.verify(~self.data.paused)
with sp.for_('permit', params) as permit:
params_hash = sp.snd(sp.snd(permit))
unsigned = sp.pack(
sp.pair(sp.pair(sp.chain_id, sp.self_address),
sp.pair(self.data.counter, params_hash)))
pk_address = sp.to_address(
sp.implicit_account(sp.hash_key(sp.fst(permit))))
permit_key = sp.pair(pk_address, params_hash)
permit_exists = self.data.permits.contains(permit_key)
effective_expiry = self.getEffectiveExpiry(
sp.pair(pk_address, params_hash))
permit_submission_timestamp = self.data.permits[permit_key]
sp.verify(
~(permit_exists &
(sp.as_nat(sp.now - permit_submission_timestamp) <
effective_expiry)), sp.pair("DUP_PERMIT", params_hash))
sp.verify(
sp.check_signature(sp.fst(permit), sp.fst(sp.snd(permit)),
unsigned), sp.pair("MISSIGNED", unsigned))
self.data.permits[sp.pair(pk_address, params_hash)] = sp.now
self.data.counter = self.data.counter + 1
def init_permit_data():
return sp.record(permits = sp.map(tkey=sp.TPair(sp.TAddress, sp.TBytes), tvalue=sp.TTimestamp),
user_expiries = sp.map(tkey=sp.TAddress, tvalue=sp.TOption(sp.TNat)),
permit_expiries = sp.map(tkey=sp.TPair(sp.TAddress, sp.TBytes), tvalue=sp.TOption(sp.TNat)),
counter = 0,
default_expiry = 50000,
max_expiry = 2628000)
def fetchPriceFromHarbinger(self,harbingerContractAddress , asset , targetAddress):
contractParams = sp.contract(sp.TPair(sp.TString , sp.TContract(sp.TPair(sp.TString , sp.TPair(sp.TTimestamp , sp.TNat)))) , harbingerContractAddress , entry_point="get").open_some()
callBack = sp.contract(sp.TPair(sp.TString , sp.TPair(sp.TTimestamp , sp.TNat)) , targetAddress , entry_point="getResponseFromHarbinger").open_some()
dataToBeSent = sp.pair(asset , callBack)
sp.transfer(dataToBeSent , sp.mutez(0) , contractParams)
def test():
scenario=sp.test_scenario()
scenario.h1("Calls back correctly when a valid asset is provided")
scenario.h2("GIVEN a Normalizer contract")
assetCode = "XTZ-USD"
contract=NormalizerContract(assetCodes=[assetCode])
scenario += contract
scenario.h2("AND a contract to call back to")
dummyContract = DummyContract()
scenario += dummyContract
scenario.h2("AND a single data point")
start1=sp.timestamp(1595104530)
high1=1
low1=2
close1=3
volume1=4
assetCode = "XTZ-USD"
scenario += contract.update(
makeMap(
assetCode=assetCode,
start=start1,
end=sp.timestamp(1595104531),
open=3059701,
high=high1,
low=low1,
close=close1,
volume=volume1
)
).run(sender=defaultOracleContractAddress)
scenario.h2("WHEN a request is made")
contractHandle = sp.contract(
sp.TPair(sp.TString, sp.TPair(sp.TTimestamp, sp.TNat)),
dummyContract.address,
entry_point = "callback"
).open_some()
param = (assetCode, contractHandle)
scenario.h2("THEN it succeeds.")
scenario += contract.get(param)
scenario.h2("AND the dummy contract captured the expected values")
scenario.verify(sp.fst(dummyContract.data.capturedCallbackValue) == assetCode)
scenario.verify(sp.fst(sp.snd(dummyContract.data.capturedCallbackValue)) == start1)
expectedPartialVWAP = Harbinger.computeVWAP(
high=high1,
low=low1,
close=close1,
volume=volume1
)
expectedPrice = expectedPartialVWAP // volume1
scenario.verify(sp.snd(sp.snd(dummyContract.data.capturedCallbackValue)) == expectedPrice)
def __init__(self, manager, registrars):
self.init(
manager=manager,
registrars=registrars,
lands=sp.big_map(tkey=sp.TString, tvalue=sp.TRecord(
A=sp.TPair(sp.TInt, sp.TInt),
B=sp.TPair(sp.TInt, sp.TInt),
C=sp.TPair(sp.TInt, sp.TInt),
D=sp.TPair(sp.TInt, sp.TInt)
)),
land_owners=sp.map(tkey=sp.TAddress, tvalue=sp.TSet(sp.TString))
)
def checkRedeem(self, address):
sp.set_type(address, sp.TAddress)
contract = sp.contract(sp.TPair(sp.TAddress, sp.TContract(
sp.TBool)), self.data.contract, entry_point="hasRedeemed").open_some()
payload = sp.pair(address, sp.contract(
sp.TBool, sp.self_address, entry_point="callback").open_some())
sp.transfer(payload, sp.mutez(0), contract)
def updateContracts(self, newParams):
sp.set_type(
newParams,
sp.TPair(
sp.TAddress,
sp.TPair(
sp.TAddress,
sp.TPair(sp.TAddress, sp.TPair(sp.TAddress,
sp.TAddress)))))
sp.verify(sp.sender == self.data.governorAddress,
message="NOT_GOVERNOR")
newGovernorContractAddress = sp.fst(newParams)
self.data.governorAddress = newGovernorContractAddress
def setExpiry(self, params):
sp.set_type(params, sp.TPair(sp.TAddress, sp.TPair(sp.TNat, sp.TOption(
sp.TBytes))))
address = sp.fst(params)
new_expiry = sp.fst(sp.snd(params))
possible_bytes = sp.snd(sp.snd(params))
sp.verify(new_expiry <= self.data.permit_data.max_expiry, self.error_message.expiry_exceeds_max())
sp.verify_equal(address, sp.sender, message=self.error_message.user_unauthorized())
sp.if possible_bytes.is_some():
some_permit = possible_bytes.open_some()
permit_key = sp.pair(address, some_permit)
sp.verify(self.data.permit_data.permits.contains(
permit_key), self.error_message.permit_nonexistent())
permit_submission_timestamp = self.data.permit_data.permits[permit_key]
effective_expiry = self.getEffectiveExpiry(permit_key)
sp.verify(sp.as_nat(sp.now - permit_submission_timestamp)
< effective_expiry, self.error_message.permit_revoked())
self.data.permit_data.permit_expiries[permit_key] = sp.some(new_expiry)
def get(self, requestPair):
sp.set_type(requestPair, sp.TPair(sp.TString, sp.TContract(sp.TPair(sp.TString, sp.TPair(sp.TTimestamp, sp.TNat)))))
# Destructure the arguments.
requestedAsset = sp.compute(sp.fst(requestPair))
callback = sp.compute(sp.snd(requestPair))
# Verify this normalizer has data for the requested asset.
sp.verify(
self.data.assetMap.contains(requestedAsset),
message="bad request"
)
# Callback with the requested data.
assetData = self.data.assetMap[requestedAsset]
normalizedPrice = assetData.computedPrice
lastUpdateTime = assetData.lastUpdateTime
callbackParam = (requestedAsset, (lastUpdateTime, normalizedPrice))
sp.transfer(callbackParam, sp.mutez(0), callback)
def __init__(self, admin, supply, **extra_storage):
contract_metadata = sp.big_map(
l = {
"": sp.bytes_of_string('tezos-storage:data'),
"data": sp.bytes_of_string(
"""{
"name": "SmartLink",
"description": "Decentralized escrow platform for Web 3.0",
"authors": ["SmartLink Dev Team <*****@*****.**>"],
"homepage": "https://smartlink.so/",
"interfaces": [ "TZIP-007", "TZIP-016"],
"symbol":"SMAK",
"icon":"ipfs://QmU2C4jU154nwA71AKHeiEj79qe7ZQC4Mf7AeUj5ALXZfe",
"decimals":"3"
}"""
)
},
tkey = sp.TString,
tvalue = sp.TBytes
)
token_metadata = sp.big_map(
l = {
0: (
0,
sp.map(
l = {
"name": sp.bytes_of_string('Smartlink'),
"decimals": sp.bytes_of_string('3'),
"symbol": sp.bytes_of_string('SMAK'),
"icon": sp.bytes_of_string('ipfs://QmU2C4jU154nwA71AKHeiEj79qe7ZQC4Mf7AeUj5ALXZfe')
},
tkey = sp.TString,
tvalue = sp.TBytes
)
)
},
tkey = sp.TNat,
tvalue = sp.TPair(sp.TNat, sp.TMap(sp.TString, sp.TBytes))
)
self.balances = sp.big_map(
l = {admin: sp.record(balance = supply, approvals = {})},
tkey = sp.TAddress,
tvalue = sp.TRecord(approvals = sp.TMap(sp.TAddress, sp.TNat), balance = sp.TNat)
)
self.init(
balances = self.balances,
metadata = contract_metadata,
token_metadata = token_metadata,
frozen_accounts = sp.big_map(tkey = sp.TAddress, tvalue = sp.TTimestamp),
totalSupply = supply,
**extra_storage
)
def delete_permits(self, permit_keys):
sp.set_type(permit_keys, sp.TList(sp.TPair(sp.TAddress, sp.TBytes)))
effective_expiry = sp.local("effective_expiry", 0)
sp.for permit_key in permit_keys:
permit_exists = self.data.permits.contains(permit_key)
sp.verify(permit_exists, sp.pair(
"NO_PERMIT_TO_DELETE", permit_key))
effective_expiry = self.getEffectiveExpiry(permit_key)
permit_submission_timestamp = self.data.permits[permit_key]
sp.verify(sp.as_nat(sp.now - permit_submission_timestamp) >= effective_expiry,
sp.pair("PERMIT_NOT_EXPIRED", permit_key))
self.delete_permit(permit_key)
def permit(self, params):
sp.set_type(params, sp.TList(
sp.TPair(sp.TKey, sp.TPair(sp.TSignature, sp.TBytes))))
sp.for permit in params:
public_key = sp.fst(permit)
signature = sp.fst(sp.snd(permit))
params_hash = sp.snd(sp.snd(permit))
#unsigned = sp.blake2b(mi.operator("SELF; ADDRESS; CHAIN_ID; PAIR; PAIR; PACK", [sp.TPair(sp.TNat, sp.TBytes)], [sp.TBytes])(sp.pair(self.data.permit_data.counter, params_hash)))
unsigned = sp.pack(sp.pair(sp.pair(sp.chain_id, sp.self_address), sp.pair(
self.data.permit_data.counter, params_hash)))
pk_address = sp.to_address(
sp.implicit_account(sp.hash_key(public_key)))
permit_key = sp.pair(pk_address, params_hash)
permit_exists = self.data.permit_data.permits.contains(permit_key)
permit_submission_timestamp = self.data.permit_data.permits[permit_key]
effective_expiry = self.getEffectiveExpiry(permit_key)
sp.verify(~ (permit_exists & (sp.as_nat(sp.now - permit_submission_timestamp) < effective_expiry)),
sp.pair(self.error_message.duplicate_permit(), params_hash))
sp.verify(sp.check_signature(public_key, signature, unsigned), sp.pair(self.error_message.permit_missigned(), unsigned))
self.data.permit_data.permits[permit_key] = sp.now
self.data.permit_data.counter = self.data.permit_data.counter + 1
def getResponseFromHarbinger(self,response):
sp.verify(self.data.admin.contains(sp.source) , "Un-authorized")
sp.set_type(response , sp.TPair(sp.TString , sp.TPair(sp.TTimestamp , sp.TNat)))
currentPrice=sp.local("currentPrice",sp.int(0))
currentPrice = sp.to_int(sp.fst(sp.ediv(sp.snd(sp.snd(response)) , sp.nat(1000)).open_some()))
currentCycle = sp.local("currentCycle" ,sp.int(0))
currentCycle = sp.fst(sp.ediv(sp.level,self.data.blocksPerCycle).open_some())
sp.verify(~self.data.cycleData.contains(currentCycle+self.data.stakingPeriod))
rangeMap = sp.local("rangeMap" , sp.map(tkey = sp.TPair(sp.TInt, sp.TInt) , tvalue = sp.TMutez))
iterator = sp.local("iterator" , sp.int(0))
sp.while iterator.value<=self.data.rangeEnd:
sp.if iterator.value+self.data.rangeStep<=self.data.rangeEnd:
rangeMap.value[sp.pair(iterator.value,iterator.value+self.data.rangeStep)] =sp.mutez(0)
rangeMap.value[(sp.int(-1)*(iterator.value+self.data.rangeStep),sp.int(-1)*iterator.value)] =sp.mutez(0)
def __init__(self):
self.init_type(sp.TRecord(
admin = sp.TPair(sp.TAddress, sp.TAddress),
infoIPFS = sp.TString,
uuid = sp.TInt,
endTime = sp.TTimestamp,
result = sp.TOption(sp.TInt),
orders = Types.orderType,
buyLongOrders = Types.buyAndSellType,
buyShortOrders = Types.buyAndSellType,
sellLongOrders = Types.buyAndSellType,
sellShortOrders = Types.buyAndSellType,
sharesLong = Types.sharesType,
sharesShort = Types.sharesType
))
def test():
scenario=sp.test_scenario()
scenario.h1("Fails a get request when an invalid asset is provided")
scenario.h2("GIVEN a Normalizer contract")
assetCode = "XTZ-USD"
contract=NormalizerContract(assetCodes=[assetCode])
scenario += contract
scenario.h2("AND a contract to call back to")
dummyContract = DummyContract()
scenario += dummyContract
scenario.h2("WHEN a request is made")
contractHandle = sp.contract(
sp.TPair(sp.TString, sp.TPair(sp.TTimestamp, sp.TNat)),
dummyContract.address,
entry_point = "callback"
).open_some()
badAssetCode = "BTC-USD" # Not XTZ-USD
param = (badAssetCode, contractHandle)
scenario.h2("THEN it fails.")
scenario += contract.get(param).run(valid=False)
def getEffectiveExpiry(self, params):
sp.set_type(params, sp.TPair(sp.TAddress, sp.TBytes))
address = sp.fst(params)
with sp.if_(
self.data.permit_expiries.contains(params)
& self.data.permit_expiries[params].is_some()):
permit_expiry = self.data.permit_expiries[params].open_some()
sp.result(permit_expiry)
with sp.else_():
with sp.if_(
self.data.user_expiries.contains(address)
& self.data.user_expiries[address].is_some()):
user_expiry = self.data.user_expiries[address].open_some()
sp.result(user_expiry)
with sp.else_():
sp.result(self.data.default_expiry)
def getEffectiveExpiry(self, params):
sp.set_type(params, sp.TPair(sp.TAddress, sp.TBytes))
address = sp.fst(params)
sp.if self.data.permit_expiries.contains(params) & self.data.permit_expiries[params].is_some():
permit_expiry = self.data.permit_expiries[params].open_some()
sp.result(permit_expiry)
import smartpy as sp
Harbinger = sp.io.import_script_from_url("file:common.py")
# Data type that represents a signed update to the Oracle.
SignedOracleDataType = sp.TPair(sp.TSignature, Harbinger.OracleDataType)
#####################################################################
# An Oracle contract accepts signed updates for a list of assets.
#
# Oracles are configured with a list of assets whose updates they
# track and a public key which will verify signatures on the asset
# data.
#
# Anyone may update the Oracle with properly signed data. Signatures
# for the oracle are provided by signing the packed bytes of the
# following Michelson data:
# 'pair <asset code | string> (pair <start | timestamp> (pair <end | timestamp> (pair <nat | open> (pair <nat | high> (pair <nat low> (pair <close | nat> <volume | nat>))))))'
#
# Anyone can request the Oracle push its data to another contract. Pushed
# data should generally be pushed to a Normalizer contract rather than
# consumed directly.
#
# Oracles can be revoked by calling the revoke entry point with the
# signature for bytes representing an Option(Key) Michelson type with
# value none. After revocation, the Oracle will refuse to process
# further updates.
#
# Updates to the Oracle must be monotonically increasing in start time.
#
# Values in the Oracle are represented as a natural numbers with six
import smartpy as sp
AUCTION_PARAMS_TYPE = sp.TRecord(opening_price=sp.TNat,
reserve_price=sp.TNat,
start_time=sp.TTimestamp,
round_time=sp.TInt,
ticket=sp.TTicket(sp.TNat))
METADATA_TYPE = sp.TMap(sp.TString, sp.TBytes)
TOKEN_METADATA_TYPE = sp.TBigMap(sp.TNat, sp.TPair(sp.TNat, METADATA_TYPE))
class NFTWallet(sp.Contract):
def __init__(self, owner):
self.add_flag("edo")
self.init_type(
sp.TRecord(admin=sp.TAddress,
tickets=sp.TBigMap(sp.TNat, sp.TTicket(sp.TNat)),
current_id=sp.TNat,
token_metadata=TOKEN_METADATA_TYPE))
self.init(admin=owner,
tickets=sp.big_map({}),
current_id=0,
token_metadata=sp.big_map({}))
@sp.entry_point
def createNft(self, metadata):
sp.set_type(metadata, METADATA_TYPE)
sp.verify(sp.sender == self.data.admin)
my_ticket = sp.ticket(self.data.current_id, 1)
def __init__(self,admin):
self.init(admin = sp.set([admin]) , bettors = sp.big_map(tkey = sp.TAddress , tvalue = sp.TMap(sp.TInt, sp.TRecord(amount = sp.TMutez , range = sp.TPair(sp.TInt,sp.TInt) , stakedAt = sp.TInt ,withdrawn = sp.TBool , withdrawnAmount = sp.TMutez))), roi = sp.pair(sp.int(6) , sp.int(10000)) , betLimit = sp.tez(10), blocksPerCycle=sp.int(4096), rangeStep = sp.int(250) , rangeEnd=sp.int(1000), stakingPeriod = sp.int(2) ,bettingPaused = sp.bool(False),withdrawalsPaused = sp.bool(False),cycleData = sp.big_map(tkey = sp.TInt , tvalue = sp.TRecord(referencePrice = sp.TInt , endingPrice = sp.TInt , concluded = sp.TBool , totalAmount = sp.TMutez ,roi = sp.TPair(sp.TInt , sp.TInt),amountByRange = sp.TMap(sp.TPair(sp.TInt , sp.TInt) , sp.TMutez))))
def buy_nft(self, swap_id):
hen_address = sp.address("KT1Hkg5qeNhfwpKW4fXvq7HGZB9z2EnmCCA9")
c = sp.contract(sp.TPair(sp.TNat, sp.TNat), hen_address, entry_point = "collect").open_some();
sp.transfer(sp.pair(1, swap_id), sp.mutez(0), c);
#####################################################################
# This file defines global types which are used across the Oracle
# and Normalizer contracts.
#####################################################################
# The type of the Oracle's data.
OracleDataType = sp.TPair(
sp.TTimestamp, # Start
sp.TPair(
sp.TTimestamp, # End
sp.TPair(
sp.TNat, # Open
sp.TPair(
sp.TNat, # High
sp.TPair(
sp.TNat, # Low
sp.TPair(
sp.TNat, # Close
sp.TNat # Volume
)
)
)
)
)
)
# Compute a VWAP with the given inputs
def computeVWAP(high, low, close, volume):
return ((high + low + close) // 3) * volume
def delete_permit(self, permit_key):
sp.set_type(permit_key, sp.TPair(sp.TAddress, sp.TBytes))
sp.if self.data.permit_data.permits.contains(permit_key):
del self.data.permit_data.permits[permit_key]
def delete_permit(self, permit_key):
sp.set_type(permit_key, sp.TPair(sp.TAddress, sp.TBytes))
with sp.if_(self.data.permits.contains(permit_key)):
del self.data.permits[permit_key]
with sp.if_(self.data.permit_expiries.contains(permit_key)):
del self.data.permit_expiries[permit_key]
def value_string(s):
return sp.variant("string", s)
def value_bytes(s):
return sp.variant("bytes", s)
def value_int(s):
return sp.variant("int", s)
# Request parameters
parameters_type = sp.TList(
sp.TPair(sp.TString, sp.TMap(sp.TString, value_type)))
def specify(spec, parameters={}):
return [(spec, parameters)]
# Full request specification type
request_type = sp.TRecord(amount=sp.TNat,
target=sp.TAddress,
job_id=sp.TBytes,
parameters=parameters_type,
timeout=sp.TTimestamp,
client_request_id=sp.TNat)
