Thanos did someting

[bytom/vapor.git] / equity / compiler / equitytest / equitytest.go

diff --git a/equity/compiler/equitytest/equitytest.go b/equity/compiler/equitytest/equitytest.go
deleted file mode 100644 (file)
index f5906b9..0000000
--- a/equity/compiler/equitytest/equitytest.go
+++ /dev/null
@@ -1,181 +0,0 @@
-package equitytest
-
-const TrivialLock = `
-contract TrivialLock() locks amount of asset {
-  clause trivialUnlock() {
-    unlock amount of asset
-  }
-}
-`
-
-const LockWithPublicKey = `
-contract LockWithPublicKey(publicKey: PublicKey) locks amount of asset {
-  clause unlockWithSig(sig: Signature) {
-    verify checkTxSig(publicKey, sig)
-    unlock amount of asset
-  }
-}
-`
-
-const LockWithPKHash = `
-contract LockWithPublicKeyHash(pubKeyHash: Hash) locks amount of asset {
-  clause spend(pubKey: PublicKey, sig: Signature) {
-    verify sha3(pubKey) == pubKeyHash
-    verify checkTxSig(pubKey, sig)
-    unlock amount of asset
-  }
-}
-`
-
-const LockWith2of3Keys = `
-contract LockWith3Keys(pubkey1, pubkey2, pubkey3: PublicKey) locks amount of asset {
-  clause unlockWith2Sigs(sig1, sig2: Signature) {
-    verify checkTxMultiSig([pubkey1, pubkey2, pubkey3], [sig1, sig2])
-    unlock amount of asset
-  }
-}
-`
-
-const LockToOutput = `
-contract LockToOutput(address: Program) locks amount of asset {
-  clause relock() {
-    lock amount of asset with address
-  }
-}
-`
-
-const TradeOffer = `
-contract TradeOffer(requestedAsset: Asset, requestedAmount: Amount, sellerProgram: Program, sellerKey: PublicKey) locks amount of asset {
-  clause trade() {
-    lock requestedAmount of requestedAsset with sellerProgram
-    unlock amount of asset
-  }
-  clause cancel(sellerSig: Signature) {
-    verify checkTxSig(sellerKey, sellerSig)
-    unlock amount of asset
-  }
-}
-`
-
-const EscrowedTransfer = `
-contract EscrowedTransfer(agent: PublicKey, sender: Program, recipient: Program) locks amount of asset {
-  clause approve(sig: Signature) {
-    verify checkTxSig(agent, sig)
-    lock amount of asset with recipient
-  }
-  clause reject(sig: Signature) {
-    verify checkTxSig(agent, sig)
-    lock amount of asset with sender
-  }
-}
-`
-
-const RevealPreimage = `
-contract RevealPreimage(hash: Hash) locks amount of asset {
-  clause reveal(string: String) {
-    verify sha3(string) == hash
-    unlock amount of asset
-  }
-}
-`
-const PriceChanger = `
-contract PriceChanger(askAmount: Amount, askAsset: Asset, sellerKey: PublicKey, sellerProg: Program) locks valueAmount of valueAsset {
-  clause changePrice(newAmount: Amount, newAsset: Asset, sig: Signature) {
-    verify checkTxSig(sellerKey, sig)
-    lock valueAmount of valueAsset with PriceChanger(newAmount, newAsset, sellerKey, sellerProg)
-  }
-  clause redeem() {
-    lock askAmount of askAsset with sellerProg
-    unlock valueAmount of valueAsset
-  }
-}
-`
-
-const TestDefineVar = `
-contract TestDefineVar(result: Integer) locks valueAmount of valueAsset {
-  clause LockWithMath(left: Integer, right: Integer) {
-    define calculate: Integer = left + right
-    verify left != calculate
-    verify result == calculate
-    unlock valueAmount of valueAsset
-  }
-}
-`
-
-const TestAssignVar = `
-contract TestAssignVar(result: Integer) locks valueAmount of valueAsset {
-  clause LockWithMath(first: Integer, second: Integer) {
-    define calculate: Integer = first
-    assign calculate = calculate + second
-    verify result == calculate
-    unlock valueAmount of valueAsset
-  }
-}
-`
-
-const TestSigIf = `
-contract TestSigIf(a: Integer, count:Integer) locks valueAmount of valueAsset {
-  clause check(b: Integer, c: Integer) {
-    verify b != count
-    if a > b {
-        verify b > c
-    } else {
-        verify a > c
-    }
-    unlock valueAmount of valueAsset
-  }
-}
-`
-const TestIfAndMultiClause = `
-contract TestIfAndMultiClause(a: Integer, cancelKey: PublicKey) locks valueAmount of valueAsset {
-  clause check(b: Integer, c: Integer) {
-    verify b != c
-    if a > b {
-        verify a > c
-    }
-    unlock valueAmount of valueAsset
-  }
-  clause cancel(sellerSig: Signature) {
-    verify checkTxSig(cancelKey, sellerSig)
-    unlock valueAmount of valueAsset
-  }
-}
-`
-
-const TestIfNesting = `
-contract TestIfNesting(a: Integer, count:Integer) locks valueAmount of valueAsset {
-  clause check(b: Integer, c: Integer, d: Integer) {
-    verify b != count
-    if a > b {
-        if d > c {
-           verify a > d
-        }
-        verify d != b
-    } else {
-        verify a > c
-    }
-    verify c != count
-    unlock valueAmount of valueAsset
-  }
-  clause cancel(e: Integer, f: Integer) {
-    verify a != e
-    if a > f {
-      verify e > count
-    }
-    verify f != count
-    unlock valueAmount of valueAsset
-  }
-}
-`
-const TestConstantMath = `
-contract TestConstantMath(result: Integer, hashByte: Hash, hashStr: Hash, outcome: Boolean) locks valueAmount of valueAsset {
-  clause calculation(left: Integer, right: Integer, boolResult: Boolean) {
-    verify result == left + right + 10
-    verify hashByte == sha3(0x31323330)
-    verify hashStr == sha3('string')
-    verify !outcome
-    verify boolResult && (result == left + 20)
-    unlock valueAmount of valueAsset
-  }
-}
-`