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)