@alpha-arcade/sdk 0.2.8 → 0.2.10

package/dist/index.js

@@ -1,5 +1,5 @@
 import algosdk2, { AtomicTransactionComposer, getApplicationAddress, modelsv2 } from 'algosdk';
-import * as algokit3 from '@algorandfoundation/algokit-utils';
+import * as algokit4 from '@algorandfoundation/algokit-utils';
 import { Decimal } from 'decimal.js';
 
 // src/modules/trading.ts
@@ -581,7 +581,7 @@ var MarketAppClient = class _MarketAppClient {
   constructor(appDetails, algod) {
     this.algod = algod;
     this.sender = appDetails.sender;
-    this.appClient = algokit3.getAppClient({
+    this.appClient = algokit4.getAppClient({
       ...appDetails,
       app: APP_SPEC
     }, algod);
@@ -979,7 +979,7 @@ var MarketAppClient = class _MarketAppClient {
         return this;
       },
       addTransaction(txn, defaultSender) {
-        promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit3.getTransactionWithSigner(txn, defaultSender ?? client.sender)));
+        promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit4.getTransactionWithSigner(txn, defaultSender ?? client.sender)));
         return this;
       },
       async atc() {
@@ -996,7 +996,7 @@ var MarketAppClient = class _MarketAppClient {
       },
       async execute(sendParams) {
         await promiseChain;
-        const result = await algokit3.sendAtomicTransactionComposer({ atc, sendParams }, client.algod);
+        const result = await algokit4.sendAtomicTransactionComposer({ atc, sendParams }, client.algod);
         return {
           ...result,
           returns: result.returns?.map((val, i) => resultMappers[i] !== void 0 ? resultMappers[i](val.returnValue) : val.returnValue)
@@ -1140,7 +1140,7 @@ var MatcherAppClient = class {
   constructor(appDetails, algod) {
     this.algod = algod;
     this.sender = appDetails.sender;
-    this.appClient = algokit3.getAppClient({
+    this.appClient = algokit4.getAppClient({
       ...appDetails,
       app: APP_SPEC2
     }, algod);
@@ -1242,7 +1242,7 @@ var MatcherAppClient = class {
         return this;
       },
       addTransaction(txn, defaultSender) {
-        promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit3.getTransactionWithSigner(txn, defaultSender ?? client.sender)));
+        promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit4.getTransactionWithSigner(txn, defaultSender ?? client.sender)));
         return this;
       },
       async atc() {
@@ -1259,7 +1259,693 @@ var MatcherAppClient = class {
       },
       async execute(sendParams) {
         await promiseChain;
-        const result = await algokit3.sendAtomicTransactionComposer({ atc, sendParams }, client.algod);
+        const result = await algokit4.sendAtomicTransactionComposer({ atc, sendParams }, client.algod);
+        return {
+          ...result,
+          returns: result.returns?.map((val, i) => resultMappers[i] !== void 0 ? resultMappers[i](val.returnValue) : val.returnValue)
+        };
+      }
+    };
+  }
+};
+var APP_SPEC3 = {
+  "hints": {
+    "on_create()uint8": {
+      "call_config": {
+        "no_op": "CREATE"
+      }
+    },
+    "setup(string,string,string,string,string)uint8": {
+      "call_config": {
+        "no_op": "CALL"
+      }
+    },
+    "match_maker(application,uint64)uint8": {
+      "call_config": {
+        "no_op": "CALL"
+      }
+    },
+    "amend_order(uint64,uint64,uint64)uint8": {
+      "call_config": {
+        "no_op": "CALL"
+      }
+    },
+    "match_taker(application)uint64": {
+      "call_config": {
+        "no_op": "CALL"
+      }
+    },
+    "delete()uint8": {
+      "call_config": {
+        "delete_application": "CALL"
+      }
+    },
+    "on_update()uint64": {
+      "call_config": {
+        "update_application": "CALL"
+      }
+    }
+  },
+  "source": {
+    "approval": "#pragma version 8
intcblock 0 1 1000000 4 256 1000000000000000000
bytecblock 0x6d61726b65745f6170705f6964 0x706f736974696f6e 0x7072696365 0x73696465 0x736c697070616765 0x6f776e6572 0x7175616e74697479 0x6665655f74696d65725f7374617274 0x7175616e746974795f66696c6c6564 0x636f6c6c61746572616c5f61737365745f6964 0x151f7c75 0x7965735f61737365745f6964 0x6e6f5f61737365745f6964 0x6665655f626173655f70657263656e74 0x00 0x61737365745f6c6973746564 0x6665655f61646472657373 0x954e7d72 0x32ce281e 0xc91e88f5 0xdb922fc2 0x 0xba1deef5
txn NumAppArgs
intc_0 // 0
==
bnz main_l16
txna ApplicationArgs 0
pushbytes 0x43db62a1 // "on_create()uint8"
==
bnz main_l15
txna ApplicationArgs 0
bytec 17 // "setup(string,string,string,string,string)uint8"
==
bnz main_l14
txna ApplicationArgs 0
bytec 18 // "match_maker(application,uint64)uint8"
==
bnz main_l13
txna ApplicationArgs 0
bytec 19 // "amend_order(uint64,uint64,uint64)uint8"
==
bnz main_l12
txna ApplicationArgs 0
bytec 20 // "match_taker(application)uint64"
==
bnz main_l11
txna ApplicationArgs 0
pushbytes 0x119e3c4b // "delete()uint8"
==
bnz main_l10
txna ApplicationArgs 0
pushbytes 0x24c3d234 // "on_update()uint64"
==
bnz main_l9
err
main_l9:
txn OnCompletion
intc_3 // UpdateApplication
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub onupdatecaster_33
intc_1 // 1
return
main_l10:
txn OnCompletion
pushint 5 // DeleteApplication
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub deletecaster_32
intc_1 // 1
return
main_l11:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub matchtakercaster_31
intc_1 // 1
return
main_l12:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub amendordercaster_30
intc_1 // 1
return
main_l13:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub matchmakercaster_29
intc_1 // 1
return
main_l14:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
!=
&&
assert
callsub setupcaster_28
intc_1 // 1
return
main_l15:
txn OnCompletion
intc_0 // NoOp
==
txn ApplicationID
intc_0 // 0
==
&&
assert
callsub oncreatecaster_27
intc_1 // 1
return
main_l16:
txn OnCompletion
intc_0 // NoOp
==
bnz main_l18
err
main_l18:
txn ApplicationID
intc_0 // 0
==
assert
callsub create_8
intc_1 // 1
return

// div_round
divround_0:
proto 2 1
frame_dig -2
frame_dig -1
/
store 9
frame_dig -2
frame_dig -1
%
pushint 500 // 500
>
bnz divround_0_l2
load 9
retsub
divround_0_l2:
load 9
intc_1 // 1
+
retsub

// div_ceil_bytes
divceilbytes_1:
proto 2 1
frame_dig -2
frame_dig -1
b/
store 17
frame_dig -2
frame_dig -1
b%
len
intc_0 // 0
>
bnz divceilbytes_1_l2
load 17
retsub
divceilbytes_1_l2:
load 17
intc_1 // 1
itob
b+
retsub

// calculate_fee
calculatefee_2:
proto 3 1
frame_dig -3
itob
store 2
frame_dig -2
itob
store 3
intc_2 // 1000000
frame_dig -2
-
itob
store 4
load 2
load 3
b*
store 2
load 2
load 4
b*
store 2
load 2
frame_dig -1
itob
b*
store 2
load 2
intc 5 // 1000000000000000000
itob
b/
btoi
retsub

// calculate_fee_commit
calculatefeecommit_3:
proto 3 1
frame_dig -3
itob
store 14
frame_dig -2
itob
store 15
intc_2 // 1000000
frame_dig -2
-
itob
store 16
load 14
load 15
b*
store 14
load 14
load 16
b*
store 14
load 14
frame_dig -1
itob
b*
store 14
load 14
intc 5 // 1000000000000000000
itob
callsub divceilbytes_1
btoi
retsub

// global_must_get
globalmustget_4:
proto 2 1
frame_dig -2
frame_dig -1
app_global_get_ex
store 1
store 0
load 1
assert
load 0
retsub

// get_app_addr
getappaddr_5:
proto 1 1
frame_dig -1
app_params_get AppAddress
store 6
store 5
load 6
assert
load 5
retsub

// send_asset
sendasset_6:
proto 4 0
itxn_begin
intc_3 // axfer
itxn_field TypeEnum
frame_dig -4
itxn_field Sender
frame_dig -3
itxn_field AssetAmount
frame_dig -2
itxn_field XferAsset
frame_dig -1
itxn_field AssetReceiver
itxn_submit
retsub

// get_funds_to_trader
getfundstotrader_7:
proto 4 0
frame_dig -4
frame_dig -2
asset_holding_get AssetBalance
store 8
store 7
load 8
bnz getfundstotrader_7_l2
global CurrentApplicationAddress
frame_dig -1
frame_dig -2
frame_dig -3
callsub sendasset_6
b getfundstotrader_7_l3
getfundstotrader_7_l2:
global CurrentApplicationAddress
frame_dig -1
frame_dig -2
frame_dig -4
callsub sendasset_6
getfundstotrader_7_l3:
retsub

// create
create_8:
proto 0 0
bytec 15 // "asset_listed"
intc_0 // 0
app_global_put
bytec 7 // "fee_timer_start"
intc_0 // 0
app_global_put
bytec_0 // "market_app_id"
intc_0 // 0
app_global_put
bytec 5 // "owner"
bytec 21 // ""
app_global_put
bytec_1 // "position"
intc_0 // 0
app_global_put
bytec_2 // "price"
intc_0 // 0
app_global_put
bytec 6 // "quantity"
intc_0 // 0
app_global_put
bytec 8 // "quantity_filled"
intc_0 // 0
app_global_put
bytec_3 // "side"
intc_0 // 0
app_global_put
bytec 4 // "slippage"
intc_0 // 0
app_global_put
retsub

// on_create
oncreate_9:
proto 0 1
intc_0 // 0
intc_1 // 1
frame_bury 0
frame_dig 0
intc 4 // 256
<
assert
retsub

// setup
setup_10:
proto 5 1
intc_0 // 0
txn Sender
global CreatorAddress
==
// unauthorized
assert
txn TypeEnum
pushint 6 // appl
==
assert
txna ApplicationArgs 0
bytec 17 // "setup(string,string,string,string,string)uint8"
==
assert
frame_dig -5
extract 2 0
btoi
intc_0 // 0
==
frame_dig -5
extract 2 0
btoi
intc_1 // 1
==
||
assert
frame_dig -3
extract 2 0
btoi
intc_0 // 0
==
frame_dig -3
extract 2 0
btoi
intc_1 // 1
==
||
assert
frame_dig -4
extract 2 0
btoi
intc_0 // 0
>
assert
frame_dig -4
extract 2 0
btoi
intc_2 // 1000000
<
assert
frame_dig -2
extract 2 0
btoi
intc_0 // 0
>
assert
bytec 15 // "asset_listed"
intc_0 // 0
txnas Assets
app_global_put
bytec_0 // "market_app_id"
global CallerApplicationID
app_global_put
bytec_1 // "position"
frame_dig -5
extract 2 0
btoi
app_global_put
bytec_3 // "side"
frame_dig -3
extract 2 0
btoi
app_global_put
bytec 6 // "quantity"
frame_dig -2
extract 2 0
btoi
app_global_put
bytec 8 // "quantity_filled"
intc_0 // 0
app_global_put
bytec_2 // "price"
frame_dig -4
extract 2 0
btoi
app_global_put
bytec 5 // "owner"
intc_1 // 1
txnas Accounts
app_global_put
bytec 4 // "slippage"
frame_dig -1
extract 2 0
btoi
app_global_put
global CurrentApplicationAddress
intc_0 // 0
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
global CurrentApplicationAddress
callsub sendasset_6
global CurrentApplicationAddress
intc_0 // 0
bytec_0 // "market_app_id"
app_global_get
bytec 11 // "yes_asset_id"
callsub globalmustget_4
global CurrentApplicationAddress
callsub sendasset_6
global CurrentApplicationAddress
intc_0 // 0
bytec_0 // "market_app_id"
app_global_get
bytec 12 // "no_asset_id"
callsub globalmustget_4
global CurrentApplicationAddress
callsub sendasset_6
bytec 7 // "fee_timer_start"
global LatestTimestamp
app_global_put
intc_1 // 1
frame_bury 0
frame_dig 0
intc 4 // 256
<
assert
retsub

// validate_match_group
validatematchgroup_11:
proto 1 0
txn GroupIndex
intc_1 // 1
+
gtxns TypeEnum
pushint 6 // appl
==
assert
txn GroupIndex
intc_1 // 1
+
gtxnsa ApplicationArgs 0
bytec 20 // "match_taker(application)uint64"
==
assert
txn GroupIndex
intc_1 // 1
+
gtxns ApplicationID
frame_dig -1
txnas Applications
==
assert
txn GroupIndex
pushint 2 // 2
+
gtxns TypeEnum
pushint 6 // appl
==
assert
txn GroupIndex
pushint 2 // 2
+
gtxnsa ApplicationArgs 0
bytec 22 // "process_potential_match(application,application)uint8"
==
assert
txn GroupIndex
pushint 2 // 2
+
gtxns ApplicationID
bytec_0 // "market_app_id"
app_global_get
==
assert
txn GroupIndex
intc_1 // 1
+
gtxns OnCompletion
intc_0 // NoOp
==
assert
txn GroupIndex
pushint 2 // 2
+
gtxns OnCompletion
intc_0 // NoOp
==
assert
retsub

// handle_fee_transfer
handlefeetransfer_12:
proto 5 0
frame_dig -5
frame_dig -4
frame_dig -3
frame_dig -2
callsub calculatefee_2
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
frame_dig -1
callsub sendasset_6
retsub

// handle_bid_ask_maker_bid
handlebidaskmakerbid_13:
proto 2 0
bytec_2 // "price"
app_global_get
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
frame_dig -2
bytec 4 // "slippage"
callsub globalmustget_4
-
>=
assert
frame_dig -2
bytec 5 // "owner"
callsub globalmustget_4
frame_dig -2
callsub getappaddr_5
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
frame_dig -1
bytec_2 // "price"
app_global_get
*
intc_2 // 1000000
/
frame_dig -1
bytec_2 // "price"
app_global_get
bytec_0 // "market_app_id"
app_global_get
bytec 13 // "fee_base_percent"
callsub globalmustget_4
callsub calculatefee_2
-
callsub getfundstotrader_7
global CurrentApplicationAddress
frame_dig -1
bytec_2 // "price"
app_global_get
bytec_0 // "market_app_id"
app_global_get
bytec 13 // "fee_base_percent"
callsub globalmustget_4
bytec_0 // "market_app_id"
app_global_get
bytec 16 // "fee_address"
callsub globalmustget_4
callsub handlefeetransfer_12
retsub

// handle_bid_ask_maker_ask
handlebidaskmakerask_14:
proto 2 0
bytec_2 // "price"
app_global_get
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
frame_dig -2
bytec 4 // "slippage"
callsub globalmustget_4
+
<=
assert
frame_dig -2
bytec 5 // "owner"
callsub globalmustget_4
frame_dig -2
callsub getappaddr_5
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bnz handlebidaskmakerask_14_l2
bytec_0 // "market_app_id"
app_global_get
bytec 11 // "yes_asset_id"
callsub globalmustget_4
b handlebidaskmakerask_14_l3
handlebidaskmakerask_14_l2:
bytec_0 // "market_app_id"
app_global_get
bytec 12 // "no_asset_id"
callsub globalmustget_4
handlebidaskmakerask_14_l3:
frame_dig -1
callsub getfundstotrader_7
retsub

// handle_maker_bid_bid_complement
handlemakerbidbidcomplement_15:
proto 2 0
bytec_2 // "price"
app_global_get
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
+
frame_dig -2
bytec 4 // "slippage"
callsub globalmustget_4
+
intc_2 // 1000000
>=
assert
global CurrentApplicationAddress
frame_dig -1
bytec_2 // "price"
app_global_get
*
intc_2 // 1000000
callsub divround_0
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
bytec_0 // "market_app_id"
app_global_get
callsub getappaddr_5
callsub sendasset_6
retsub

// handle_maker_ask_ask_complement
handlemakeraskaskcomplement_16:
proto 2 0
bytec_2 // "price"
app_global_get
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
frame_dig -2
bytec 4 // "slippage"
callsub globalmustget_4
-
+
intc_2 // 1000000
<=
assert
global CurrentApplicationAddress
frame_dig -1
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bnz handlemakeraskaskcomplement_16_l2
bytec_0 // "market_app_id"
app_global_get
bytec 11 // "yes_asset_id"
callsub globalmustget_4
b handlemakeraskaskcomplement_16_l3
handlemakeraskaskcomplement_16_l2:
bytec_0 // "market_app_id"
app_global_get
bytec 12 // "no_asset_id"
callsub globalmustget_4
handlemakeraskaskcomplement_16_l3:
bytec_0 // "market_app_id"
app_global_get
callsub getappaddr_5
callsub sendasset_6
retsub

// match_maker
matchmaker_17:
proto 2 1
intc_0 // 0
frame_dig -2
callsub validatematchgroup_11
frame_dig -1
bytec 6 // "quantity"
app_global_get
bytec 8 // "quantity_filled"
app_global_get
-
<=
assert
bytec 4 // "slippage"
app_global_get
intc_0 // 0
>
bnz matchmaker_17_l11
matchmaker_17_l1:
bytec 4 // "slippage"
app_global_get
intc_0 // 0
>
bnz matchmaker_17_l10
matchmaker_17_l2:
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
||
bnz matchmaker_17_l9
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
||
bnz matchmaker_17_l8
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
||
bnz matchmaker_17_l7
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -2
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
||
bz matchmaker_17_l12
frame_dig -2
txnas Applications
frame_dig -1
callsub handlemakeraskaskcomplement_16
b matchmaker_17_l12
matchmaker_17_l7:
frame_dig -2
txnas Applications
frame_dig -1
callsub handlemakerbidbidcomplement_15
b matchmaker_17_l12
matchmaker_17_l8:
frame_dig -2
txnas Applications
frame_dig -1
callsub handlebidaskmakerask_14
b matchmaker_17_l12
matchmaker_17_l9:
frame_dig -2
txnas Applications
frame_dig -1
callsub handlebidaskmakerbid_13
b matchmaker_17_l12
matchmaker_17_l10:
global LatestTimestamp
bytec 7 // "fee_timer_start"
app_global_get
pushint 120 // 120
+
<
assert
b matchmaker_17_l2
matchmaker_17_l11:
frame_dig -2
txnas Applications
bytec 4 // "slippage"
callsub globalmustget_4
intc_0 // 0
>
bytec 7 // "fee_timer_start"
app_global_get
frame_dig -2
txnas Applications
bytec 7 // "fee_timer_start"
callsub globalmustget_4
<=
&&
assert
b matchmaker_17_l1
matchmaker_17_l12:
bytec 8 // "quantity_filled"
bytec 8 // "quantity_filled"
app_global_get
frame_dig -1
+
app_global_put
intc_1 // 1
frame_bury 0
frame_dig 0
intc 4 // 256
<
assert
retsub

// validate_taker_match_group
validatetakermatchgroup_18:
proto 1 0
txn GroupIndex
intc_1 // 1
-
gtxns TypeEnum
pushint 6 // appl
==
assert
txn GroupIndex
intc_1 // 1
-
gtxnsa ApplicationArgs 0
bytec 18 // "match_maker(application,uint64)uint8"
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns ApplicationID
frame_dig -1
==
assert
txn GroupIndex
intc_1 // 1
+
gtxns TypeEnum
pushint 6 // appl
==
assert
txn GroupIndex
intc_1 // 1
+
gtxnsa ApplicationArgs 0
bytec 22 // "process_potential_match(application,application)uint8"
==
assert
txn GroupIndex
intc_1 // 1
+
gtxns ApplicationID
bytec_0 // "market_app_id"
app_global_get
==
assert
txn GroupIndex
intc_1 // 1
-
gtxnsa ApplicationArgs 2
btoi
bytec 6 // "quantity"
app_global_get
bytec 8 // "quantity_filled"
app_global_get
-
<=
assert
txn GroupIndex
intc_1 // 1
-
gtxns OnCompletion
intc_0 // NoOp
==
assert
txn GroupIndex
intc_1 // 1
+
gtxns OnCompletion
intc_0 // NoOp
==
assert
retsub

// handle_taker_bid_ask_bid
handletakerbidaskbid_19:
proto 2 0
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
+
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
>=
assert
frame_dig -2
bytec 5 // "owner"
callsub globalmustget_4
frame_dig -2
callsub getappaddr_5
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
frame_dig -1
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
*
intc_2 // 1000000
/
callsub getfundstotrader_7
global CurrentApplicationAddress
frame_dig -1
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
bytec_0 // "market_app_id"
app_global_get
bytec 13 // "fee_base_percent"
callsub globalmustget_4
bytec_0 // "market_app_id"
app_global_get
bytec 16 // "fee_address"
callsub globalmustget_4
callsub handlefeetransfer_12
retsub

// handle_taker_bid_ask_ask
handletakerbidaskask_20:
proto 2 0
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
-
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
<=
assert
frame_dig -2
bytec 5 // "owner"
callsub globalmustget_4
frame_dig -2
callsub getappaddr_5
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bnz handletakerbidaskask_20_l2
bytec_0 // "market_app_id"
app_global_get
bytec 11 // "yes_asset_id"
callsub globalmustget_4
b handletakerbidaskask_20_l3
handletakerbidaskask_20_l2:
bytec_0 // "market_app_id"
app_global_get
bytec 12 // "no_asset_id"
callsub globalmustget_4
handletakerbidaskask_20_l3:
frame_dig -1
callsub getfundstotrader_7
retsub

// handle_taker_bid_bid_complement
handletakerbidbidcomplement_21:
proto 2 0
bytec_2 // "price"
app_global_get
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
+
bytec 4 // "slippage"
app_global_get
+
intc_2 // 1000000
>=
assert
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
+
intc_2 // 1000000
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
-
>
bnz handletakerbidbidcomplement_21_l2
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
+
store 18
b handletakerbidbidcomplement_21_l3
handletakerbidbidcomplement_21_l2:
intc_2 // 1000000
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
-
store 18
handletakerbidbidcomplement_21_l3:
global CurrentApplicationAddress
frame_dig -1
load 18
*
intc_2 // 1000000
callsub divround_0
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
bytec_0 // "market_app_id"
app_global_get
callsub getappaddr_5
callsub sendasset_6
global CurrentApplicationAddress
frame_dig -1
load 18
bytec_0 // "market_app_id"
app_global_get
bytec 13 // "fee_base_percent"
callsub globalmustget_4
bytec_0 // "market_app_id"
app_global_get
bytec 16 // "fee_address"
callsub globalmustget_4
callsub handlefeetransfer_12
retsub

// handle_taker_ask_ask_complement
handletakeraskaskcomplement_22:
proto 2 0
bytec_2 // "price"
app_global_get
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
+
bytec 4 // "slippage"
app_global_get
-
intc_2 // 1000000
<=
assert
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
-
intc_2 // 1000000
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
-
<
bnz handletakeraskaskcomplement_22_l5
intc_2 // 1000000
frame_dig -2
bytec_2 // "price"
callsub globalmustget_4
-
store 19
handletakeraskaskcomplement_22_l2:
global CurrentApplicationAddress
frame_dig -1
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bnz handletakeraskaskcomplement_22_l4
bytec_0 // "market_app_id"
app_global_get
bytec 11 // "yes_asset_id"
callsub globalmustget_4
b handletakeraskaskcomplement_22_l6
handletakeraskaskcomplement_22_l4:
bytec_0 // "market_app_id"
app_global_get
bytec 12 // "no_asset_id"
callsub globalmustget_4
b handletakeraskaskcomplement_22_l6
handletakeraskaskcomplement_22_l5:
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
-
store 19
b handletakeraskaskcomplement_22_l2
handletakeraskaskcomplement_22_l6:
bytec_0 // "market_app_id"
app_global_get
callsub getappaddr_5
callsub sendasset_6
retsub

// amend_order
amendorder_23:
proto 3 1
intc_0 // 0
txn TypeEnum
pushint 6 // appl
==
assert
txna ApplicationArgs 0
bytec 19 // "amend_order(uint64,uint64,uint64)uint8"
==
assert
txn Sender
bytec 5 // "owner"
app_global_get
==
assert
bytec 8 // "quantity_filled"
app_global_get
intc_0 // 0
==
assert
frame_dig -3
intc_0 // 0
>
assert
frame_dig -3
intc_2 // 1000000
<
assert
frame_dig -2
intc_0 // 0
>
assert
frame_dig -3
bytec_2 // "price"
app_global_get
!=
frame_dig -2
bytec 6 // "quantity"
app_global_get
!=
||
frame_dig -1
bytec 4 // "slippage"
app_global_get
!=
||
assert
bytec_3 // "side"
app_global_get
intc_1 // 1
==
bnz amendorder_23_l5
bytec 15 // "asset_listed"
app_global_get
store 13
frame_dig -2
bytec 6 // "quantity"
app_global_get
>
bnz amendorder_23_l4
bytec 6 // "quantity"
app_global_get
frame_dig -2
-
store 12
load 12
intc_0 // 0
>
bz amendorder_23_l9
global CurrentApplicationAddress
load 12
load 13
txn Sender
callsub sendasset_6
b amendorder_23_l9
amendorder_23_l4:
frame_dig -2
bytec 6 // "quantity"
app_global_get
-
store 12
txn GroupIndex
intc_0 // 0
>
assert
txn GroupIndex
intc_1 // 1
-
gtxns TypeEnum
intc_3 // axfer
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns Sender
txn Sender
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns AssetReceiver
global CurrentApplicationAddress
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns XferAsset
load 13
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns AssetAmount
load 12
==
assert
b amendorder_23_l9
amendorder_23_l5:
bytec 6 // "quantity"
app_global_get
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
+
*
intc_2 // 1000000
/
bytec 6 // "quantity"
app_global_get
bytec_2 // "price"
app_global_get
bytec 4 // "slippage"
app_global_get
+
bytec_0 // "market_app_id"
app_global_get
bytec 13 // "fee_base_percent"
callsub globalmustget_4
callsub calculatefeecommit_3
+
store 10
frame_dig -2
frame_dig -3
frame_dig -1
+
*
intc_2 // 1000000
/
frame_dig -2
frame_dig -3
frame_dig -1
+
bytec_0 // "market_app_id"
app_global_get
bytec 13 // "fee_base_percent"
callsub globalmustget_4
callsub calculatefeecommit_3
+
store 11
load 11
load 10
>
bnz amendorder_23_l8
load 10
load 11
-
store 12
load 12
intc_0 // 0
>
bz amendorder_23_l9
global CurrentApplicationAddress
load 12
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
txn Sender
callsub sendasset_6
b amendorder_23_l9
amendorder_23_l8:
load 11
load 10
-
store 12
txn GroupIndex
intc_0 // 0
>
assert
txn GroupIndex
intc_1 // 1
-
gtxns TypeEnum
intc_3 // axfer
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns Sender
txn Sender
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns AssetReceiver
global CurrentApplicationAddress
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns XferAsset
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
==
assert
txn GroupIndex
intc_1 // 1
-
gtxns AssetAmount
load 12
==
assert
amendorder_23_l9:
bytec_2 // "price"
frame_dig -3
app_global_put
bytec 6 // "quantity"
frame_dig -2
app_global_put
bytec 4 // "slippage"
frame_dig -1
app_global_put
bytec 7 // "fee_timer_start"
global LatestTimestamp
app_global_put
intc_1 // 1
frame_bury 0
frame_dig 0
intc 4 // 256
<
assert
retsub

// match_taker
matchtaker_24:
proto 1 1
intc_0 // 0
frame_dig -1
txnas Applications
callsub validatetakermatchgroup_18
frame_dig -1
txnas Applications
bytec 4 // "slippage"
callsub globalmustget_4
intc_0 // 0
>
bnz matchtaker_24_l11
matchtaker_24_l1:
bytec 4 // "slippage"
app_global_get
intc_0 // 0
>
bnz matchtaker_24_l10
matchtaker_24_l2:
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
||
bnz matchtaker_24_l9
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
||
bnz matchtaker_24_l8
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_1 // 1
==
&&
||
bnz matchtaker_24_l7
bytec_1 // "position"
app_global_get
intc_0 // 0
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_1 // 1
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
bytec_1 // "position"
app_global_get
intc_1 // 1
==
bytec_3 // "side"
app_global_get
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_1 // "position"
callsub globalmustget_4
intc_0 // 0
==
&&
frame_dig -1
txnas Applications
bytec_3 // "side"
callsub globalmustget_4
intc_0 // 0
==
&&
||
bz matchtaker_24_l12
frame_dig -1
txnas Applications
txn GroupIndex
intc_1 // 1
-
gtxnsa ApplicationArgs 2
btoi
callsub handletakeraskaskcomplement_22
b matchtaker_24_l12
matchtaker_24_l7:
frame_dig -1
txnas Applications
txn GroupIndex
intc_1 // 1
-
gtxnsa ApplicationArgs 2
btoi
callsub handletakerbidbidcomplement_21
b matchtaker_24_l12
matchtaker_24_l8:
frame_dig -1
txnas Applications
txn GroupIndex
intc_1 // 1
-
gtxnsa ApplicationArgs 2
btoi
callsub handletakerbidaskask_20
b matchtaker_24_l12
matchtaker_24_l9:
frame_dig -1
txnas Applications
txn GroupIndex
intc_1 // 1
-
gtxnsa ApplicationArgs 2
btoi
callsub handletakerbidaskbid_19
b matchtaker_24_l12
matchtaker_24_l10:
global LatestTimestamp
bytec 7 // "fee_timer_start"
app_global_get
pushint 120 // 120
+
<
assert
b matchtaker_24_l2
matchtaker_24_l11:
bytec 4 // "slippage"
app_global_get
intc_0 // 0
>
frame_dig -1
txnas Applications
bytec 7 // "fee_timer_start"
callsub globalmustget_4
bytec 7 // "fee_timer_start"
app_global_get
<=
&&
assert
b matchtaker_24_l1
matchtaker_24_l12:
bytec 8 // "quantity_filled"
bytec 8 // "quantity_filled"
app_global_get
txn GroupIndex
intc_1 // 1
-
gtxnsa ApplicationArgs 2
btoi
+
app_global_put
intc_1 // 1
frame_bury 0
retsub

// delete
delete_25:
proto 0 1
intc_0 // 0
txn Sender
global CreatorAddress
==
txn Sender
bytec_0 // "market_app_id"
app_global_get
pushbytes 0x657363726f775f63616e63656c5f61646472657373 // "escrow_cancel_address"
callsub globalmustget_4
==
||
assert
itxn_begin
intc_3 // axfer
itxn_field TypeEnum
bytec_0 // "market_app_id"
app_global_get
bytec 9 // "collateral_asset_id"
callsub globalmustget_4
itxn_field XferAsset
bytec 5 // "owner"
app_global_get
itxn_field AssetReceiver
intc_0 // 0
itxn_field Fee
intc_0 // 0
itxn_field AssetAmount
bytec 5 // "owner"
app_global_get
itxn_field AssetCloseTo
itxn_submit
itxn_begin
intc_3 // axfer
itxn_field TypeEnum
bytec_0 // "market_app_id"
app_global_get
bytec 11 // "yes_asset_id"
callsub globalmustget_4
itxn_field XferAsset
bytec 5 // "owner"
app_global_get
itxn_field AssetReceiver
intc_0 // 0
itxn_field Fee
intc_0 // 0
itxn_field AssetAmount
bytec 5 // "owner"
app_global_get
itxn_field AssetCloseTo
itxn_submit
itxn_begin
intc_3 // axfer
itxn_field TypeEnum
bytec_0 // "market_app_id"
app_global_get
bytec 12 // "no_asset_id"
callsub globalmustget_4
itxn_field XferAsset
bytec 5 // "owner"
app_global_get
itxn_field AssetReceiver
intc_0 // 0
itxn_field Fee
intc_0 // 0
itxn_field AssetAmount
bytec 5 // "owner"
app_global_get
itxn_field AssetCloseTo
itxn_submit
itxn_begin
intc_1 // pay
itxn_field TypeEnum
intc_0 // 0
itxn_field Amount
bytec 5 // "owner"
app_global_get
itxn_field Receiver
intc_0 // 0
itxn_field Fee
bytec 5 // "owner"
app_global_get
itxn_field CloseRemainderTo
itxn_submit
intc_1 // 1
frame_bury 0
frame_dig 0
intc 4 // 256
<
assert
retsub

// on_update
onupdate_26:
proto 0 1
intc_0 // 0
txn Sender
bytec_0 // "market_app_id"
app_global_get
pushbytes 0x6d61726b65745f667269656e645f61646472 // "market_friend_addr"
callsub globalmustget_4
==
global GroupSize
intc_1 // 1
==
&&
assert
intc_1 // 1
frame_bury 0
retsub

// on_create_caster
oncreatecaster_27:
proto 0 0
intc_0 // 0
callsub oncreate_9
frame_bury 0
bytec 10 // 0x151f7c75
bytec 14 // 0x00
intc_0 // 0
frame_dig 0
setbyte
concat
log
retsub

// setup_caster
setupcaster_28:
proto 0 0
intc_0 // 0
bytec 21 // ""
dupn 4
txna ApplicationArgs 1
frame_bury 1
txna ApplicationArgs 2
frame_bury 2
txna ApplicationArgs 3
frame_bury 3
txna ApplicationArgs 4
frame_bury 4
txna ApplicationArgs 5
frame_bury 5
frame_dig 1
frame_dig 2
frame_dig 3
frame_dig 4
frame_dig 5
callsub setup_10
frame_bury 0
bytec 10 // 0x151f7c75
bytec 14 // 0x00
intc_0 // 0
frame_dig 0
setbyte
concat
log
retsub

// match_maker_caster
matchmakercaster_29:
proto 0 0
intc_0 // 0
dupn 2
txna ApplicationArgs 1
intc_0 // 0
getbyte
frame_bury 1
txna ApplicationArgs 2
btoi
frame_bury 2
frame_dig 1
frame_dig 2
callsub matchmaker_17
frame_bury 0
bytec 10 // 0x151f7c75
bytec 14 // 0x00
intc_0 // 0
frame_dig 0
setbyte
concat
log
retsub

// amend_order_caster
amendordercaster_30:
proto 0 0
intc_0 // 0
dupn 3
txna ApplicationArgs 1
btoi
frame_bury 1
txna ApplicationArgs 2
btoi
frame_bury 2
txna ApplicationArgs 3
btoi
frame_bury 3
frame_dig 1
frame_dig 2
frame_dig 3
callsub amendorder_23
frame_bury 0
bytec 10 // 0x151f7c75
bytec 14 // 0x00
intc_0 // 0
frame_dig 0
setbyte
concat
log
retsub

// match_taker_caster
matchtakercaster_31:
proto 0 0
intc_0 // 0
dup
txna ApplicationArgs 1
intc_0 // 0
getbyte
frame_bury 1
frame_dig 1
callsub matchtaker_24
frame_bury 0
bytec 10 // 0x151f7c75
frame_dig 0
itob
concat
log
retsub

// delete_caster
deletecaster_32:
proto 0 0
intc_0 // 0
callsub delete_25
frame_bury 0
bytec 10 // 0x151f7c75
bytec 14 // 0x00
intc_0 // 0
frame_dig 0
setbyte
concat
log
retsub

// on_update_caster
onupdatecaster_33:
proto 0 0
intc_0 // 0
callsub onupdate_26
frame_bury 0
bytec 10 // 0x151f7c75
frame_dig 0
itob
concat
log
retsub",
+    "clear": "I3ByYWdtYSB2ZXJzaW9uIDgKcHVzaGludCAwIC8vIDAKcmV0dXJu"
+  },
+  "state": {
+    "global": {
+      "num_byte_slices": 1,
+      "num_uints": 9
+    },
+    "local": {
+      "num_byte_slices": 0,
+      "num_uints": 0
+    }
+  },
+  "schema": {
+    "global": {
+      "declared": {
+        "asset_listed": {
+          "type": "uint64",
+          "key": "asset_listed",
+          "descr": "The asset id of the escrow"
+        },
+        "fee_timer_start": {
+          "type": "uint64",
+          "key": "fee_timer_start",
+          "descr": "The timestamp of the fee timer start"
+        },
+        "market_app_id": {
+          "type": "uint64",
+          "key": "market_app_id",
+          "descr": "The id of the market app"
+        },
+        "owner": {
+          "type": "bytes",
+          "key": "owner",
+          "descr": "The owner of the escrow"
+        },
+        "position": {
+          "type": "uint64",
+          "key": "position",
+          "descr": "The position of the escrow: yes/no"
+        },
+        "price": {
+          "type": "uint64",
+          "key": "price",
+          "descr": "The price of the escrow"
+        },
+        "quantity": {
+          "type": "uint64",
+          "key": "quantity",
+          "descr": "The quantity of the escrow"
+        },
+        "quantity_filled": {
+          "type": "uint64",
+          "key": "quantity_filled",
+          "descr": "The quantity of the escrow filled"
+        },
+        "side": {
+          "type": "uint64",
+          "key": "side",
+          "descr": "The side of the escrow: buy/sell"
+        },
+        "slippage": {
+          "type": "uint64",
+          "key": "slippage",
+          "descr": "The slippage of the escrow. 0 if limit."
+        }
+      },
+      "reserved": {}
+    },
+    "local": {
+      "declared": {},
+      "reserved": {}
+    }
+  },
+  "contract": {
+    "name": "escrow_app",
+    "methods": [
+      {
+        "name": "on_create",
+        "args": [],
+        "returns": {
+          "type": "uint8"
+        }
+      },
+      {
+        "name": "setup",
+        "args": [
+          {
+            "type": "string",
+            "name": "position"
+          },
+          {
+            "type": "string",
+            "name": "price"
+          },
+          {
+            "type": "string",
+            "name": "side"
+          },
+          {
+            "type": "string",
+            "name": "quantity"
+          },
+          {
+            "type": "string",
+            "name": "slippage"
+          }
+        ],
+        "returns": {
+          "type": "uint8"
+        }
+      },
+      {
+        "name": "match_maker",
+        "args": [
+          {
+            "type": "application",
+            "name": "taker"
+          },
+          {
+            "type": "uint64",
+            "name": "match_quantity"
+          }
+        ],
+        "returns": {
+          "type": "uint8"
+        }
+      },
+      {
+        "name": "amend_order",
+        "args": [
+          {
+            "type": "uint64",
+            "name": "price"
+          },
+          {
+            "type": "uint64",
+            "name": "quantity"
+          },
+          {
+            "type": "uint64",
+            "name": "slippage"
+          }
+        ],
+        "returns": {
+          "type": "uint8"
+        }
+      },
+      {
+        "name": "match_taker",
+        "args": [
+          {
+            "type": "application",
+            "name": "maker"
+          }
+        ],
+        "returns": {
+          "type": "uint64"
+        }
+      },
+      {
+        "name": "delete",
+        "args": [],
+        "returns": {
+          "type": "uint8"
+        }
+      },
+      {
+        "name": "on_update",
+        "args": [],
+        "returns": {
+          "type": "uint64"
+        }
+      }
+    ],
+    "networks": {}
+  },
+  "bare_call_config": {
+    "no_op": "CREATE"
+  }
+};
+var EscrowAppCallFactory = class {
+  /**
+   * Gets available create call factories
+   */
+  static get create() {
+    return {
+      /**
+       * Constructs a create call for the escrow_app smart contract using a bare call
+       *
+       * @param params Any parameters for the call
+       * @returns A TypedCallParams object for the call
+       */
+      bare(params = {}) {
+        return {
+          method: void 0,
+          methodArgs: void 0,
+          ...params
+        };
+      },
+      /**
+       * Constructs a create call for the escrow_app smart contract using the on_create()uint8 ABI method
+       *
+       * @param args Any args for the contract call
+       * @param params Any additional parameters for the call
+       * @returns A TypedCallParams object for the call
+       */
+      onCreate(args, params = {}) {
+        return {
+          method: "on_create()uint8",
+          methodArgs: Array.isArray(args) ? args : [],
+          ...params
+        };
+      }
+    };
+  }
+  /**
+   * Gets available update call factories
+   */
+  static get update() {
+    return {
+      /**
+       * Constructs an update call for the escrow_app smart contract using the on_update()uint64 ABI method
+       *
+       * @param args Any args for the contract call
+       * @param params Any additional parameters for the call
+       * @returns A TypedCallParams object for the call
+       */
+      onUpdate(args, params = {}) {
+        return {
+          method: "on_update()uint64",
+          methodArgs: Array.isArray(args) ? args : [],
+          ...params
+        };
+      }
+    };
+  }
+  /**
+   * Gets available delete call factories
+   */
+  static get delete() {
+    return {
+      /**
+       * Constructs a delete call for the escrow_app smart contract using the delete()uint8 ABI method
+       *
+       * @param args Any args for the contract call
+       * @param params Any additional parameters for the call
+       * @returns A TypedCallParams object for the call
+       */
+      delete(args, params = {}) {
+        return {
+          method: "delete()uint8",
+          methodArgs: Array.isArray(args) ? args : [],
+          ...params
+        };
+      }
+    };
+  }
+  /**
+   * Constructs a no op call for the setup(string,string,string,string,string)uint8 ABI method
+   *
+   * @param args Any args for the contract call
+   * @param params Any additional parameters for the call
+   * @returns A TypedCallParams object for the call
+   */
+  static setup(args, params) {
+    return {
+      method: "setup(string,string,string,string,string)uint8",
+      methodArgs: Array.isArray(args) ? args : [args.position, args.price, args.side, args.quantity, args.slippage],
+      ...params
+    };
+  }
+  /**
+   * Constructs a no op call for the match_maker(application,uint64)uint8 ABI method
+   *
+   * @param args Any args for the contract call
+   * @param params Any additional parameters for the call
+   * @returns A TypedCallParams object for the call
+   */
+  static matchMaker(args, params) {
+    return {
+      method: "match_maker(application,uint64)uint8",
+      methodArgs: Array.isArray(args) ? args : [args.taker, args.matchQuantity],
+      ...params
+    };
+  }
+  /**
+   * Constructs a no op call for the amend_order(uint64,uint64,uint64)uint8 ABI method
+   *
+   * @param args Any args for the contract call
+   * @param params Any additional parameters for the call
+   * @returns A TypedCallParams object for the call
+   */
+  static amendOrder(args, params) {
+    return {
+      method: "amend_order(uint64,uint64,uint64)uint8",
+      methodArgs: Array.isArray(args) ? args : [args.price, args.quantity, args.slippage],
+      ...params
+    };
+  }
+  /**
+   * Constructs a no op call for the match_taker(application)uint64 ABI method
+   *
+   * @param args Any args for the contract call
+   * @param params Any additional parameters for the call
+   * @returns A TypedCallParams object for the call
+   */
+  static matchTaker(args, params) {
+    return {
+      method: "match_taker(application)uint64",
+      methodArgs: Array.isArray(args) ? args : [args.maker],
+      ...params
+    };
+  }
+};
+var EscrowAppClient = class _EscrowAppClient {
+  /**
+   * Creates a new instance of `EscrowAppClient`
+   *
+   * @param appDetails appDetails The details to identify the app to deploy
+   * @param algod An algod client instance
+   */
+  constructor(appDetails, algod) {
+    this.algod = algod;
+    this.sender = appDetails.sender;
+    this.appClient = algokit4.getAppClient({
+      ...appDetails,
+      app: APP_SPEC3
+    }, algod);
+  }
+  /**
+   * The underlying `ApplicationClient` for when you want to have more flexibility
+   */
+  appClient;
+  sender;
+  /**
+   * Checks for decode errors on the AppCallTransactionResult and maps the return value to the specified generic type
+   *
+   * @param result The AppCallTransactionResult to be mapped
+   * @param returnValueFormatter An optional delegate to format the return value if required
+   * @returns The smart contract response with an updated return value
+   */
+  mapReturnValue(result, returnValueFormatter) {
+    if (result.return?.decodeError) {
+      throw result.return.decodeError;
+    }
+    const returnValue = result.return?.returnValue !== void 0 && returnValueFormatter !== void 0 ? returnValueFormatter(result.return.returnValue) : result.return?.returnValue;
+    return { ...result, return: returnValue };
+  }
+  /**
+   * Calls the ABI method with the matching signature using an onCompletion code of NO_OP
+   *
+   * @param typedCallParams An object containing the method signature, args, and any other relevant parameters
+   * @param returnValueFormatter An optional delegate which when provided will be used to map non-undefined return values to the target type
+   * @returns The result of the smart contract call
+   */
+  async call(typedCallParams, returnValueFormatter) {
+    return this.mapReturnValue(await this.appClient.call(typedCallParams), returnValueFormatter);
+  }
+  /**
+   * Idempotently deploys the escrow_app smart contract.
+   *
+   * @param params The arguments for the contract calls and any additional parameters for the call
+   * @returns The deployment result
+   */
+  deploy(params = {}) {
+    const createArgs = params.createCall?.(EscrowAppCallFactory.create);
+    const updateArgs = params.updateCall?.(EscrowAppCallFactory.update);
+    const deleteArgs = params.deleteCall?.(EscrowAppCallFactory.delete);
+    return this.appClient.deploy({
+      ...params,
+      updateArgs,
+      deleteArgs,
+      createArgs,
+      createOnCompleteAction: createArgs?.onCompleteAction
+    });
+  }
+  /**
+   * Gets available create methods
+   */
+  get create() {
+    const $this = this;
+    return {
+      /**
+       * Creates a new instance of the escrow_app smart contract using a bare call.
+       *
+       * @param args The arguments for the bare call
+       * @returns The create result
+       */
+      async bare(args = {}) {
+        return $this.mapReturnValue(await $this.appClient.create(args));
+      },
+      /**
+       * Creates a new instance of the escrow_app smart contract using the on_create()uint8 ABI method.
+       *
+       * @param args The arguments for the smart contract call
+       * @param params Any additional parameters for the call
+       * @returns The create result
+       */
+      async onCreate(args, params = {}) {
+        return $this.mapReturnValue(await $this.appClient.create(EscrowAppCallFactory.create.onCreate(args, params)));
+      }
+    };
+  }
+  /**
+   * Gets available update methods
+   */
+  get update() {
+    const $this = this;
+    return {
+      /**
+       * Updates an existing instance of the escrow_app smart contract using the on_update()uint64 ABI method.
+       *
+       * @param args The arguments for the smart contract call
+       * @param params Any additional parameters for the call
+       * @returns The update result
+       */
+      async onUpdate(args, params = {}) {
+        return $this.mapReturnValue(await $this.appClient.update(EscrowAppCallFactory.update.onUpdate(args, params)));
+      }
+    };
+  }
+  /**
+   * Gets available delete methods
+   */
+  get delete() {
+    const $this = this;
+    return {
+      /**
+       * Deletes an existing instance of the escrow_app smart contract using the delete()uint8 ABI method.
+       *
+       * @param args The arguments for the smart contract call
+       * @param params Any additional parameters for the call
+       * @returns The delete result
+       */
+      async delete(args, params = {}) {
+        return $this.mapReturnValue(await $this.appClient.delete(EscrowAppCallFactory.delete.delete(args, params)));
+      }
+    };
+  }
+  /**
+   * Makes a clear_state call to an existing instance of the escrow_app smart contract.
+   *
+   * @param args The arguments for the bare call
+   * @returns The clear_state result
+   */
+  clearState(args = {}) {
+    return this.appClient.clearState(args);
+  }
+  /**
+   * Calls the setup(string,string,string,string,string)uint8 ABI method.
+   *
+   * @param args The arguments for the contract call
+   * @param params Any additional parameters for the call
+   * @returns The result of the call
+   */
+  setup(args, params = {}) {
+    return this.call(EscrowAppCallFactory.setup(args, params));
+  }
+  /**
+   * Calls the match_maker(application,uint64)uint8 ABI method.
+   *
+   * @param args The arguments for the contract call
+   * @param params Any additional parameters for the call
+   * @returns The result of the call
+   */
+  matchMaker(args, params = {}) {
+    return this.call(EscrowAppCallFactory.matchMaker(args, params));
+  }
+  /**
+   * Calls the amend_order(uint64,uint64,uint64)uint8 ABI method.
+   *
+   * @param args The arguments for the contract call
+   * @param params Any additional parameters for the call
+   * @returns The result of the call
+   */
+  amendOrder(args, params = {}) {
+    return this.call(EscrowAppCallFactory.amendOrder(args, params));
+  }
+  /**
+   * Calls the match_taker(application)uint64 ABI method.
+   *
+   * @param args The arguments for the contract call
+   * @param params Any additional parameters for the call
+   * @returns The result of the call
+   */
+  matchTaker(args, params = {}) {
+    return this.call(EscrowAppCallFactory.matchTaker(args, params));
+  }
+  /**
+   * Extracts a binary state value out of an AppState dictionary
+   *
+   * @param state The state dictionary containing the state value
+   * @param key The key of the state value
+   * @returns A BinaryState instance containing the state value, or undefined if the key was not found
+   */
+  static getBinaryState(state, key) {
+    const value = state[key];
+    if (!value) return void 0;
+    if (!("valueRaw" in value))
+      throw new Error(`Failed to parse state value for ${key}; received an int when expected a byte array`);
+    return {
+      asString() {
+        return value.value;
+      },
+      asByteArray() {
+        return value.valueRaw;
+      }
+    };
+  }
+  /**
+   * Extracts a integer state value out of an AppState dictionary
+   *
+   * @param state The state dictionary containing the state value
+   * @param key The key of the state value
+   * @returns An IntegerState instance containing the state value, or undefined if the key was not found
+   */
+  static getIntegerState(state, key) {
+    const value = state[key];
+    if (!value) return void 0;
+    if ("valueRaw" in value)
+      throw new Error(`Failed to parse state value for ${key}; received a byte array when expected a number`);
+    return {
+      asBigInt() {
+        return typeof value.value === "bigint" ? value.value : BigInt(value.value);
+      },
+      asNumber() {
+        return typeof value.value === "bigint" ? Number(value.value) : value.value;
+      }
+    };
+  }
+  /**
+   * Returns the smart contract's global state wrapped in a strongly typed accessor with options to format the stored value
+   */
+  async getGlobalState() {
+    const state = await this.appClient.getGlobalState();
+    return {
+      get assetListed() {
+        return _EscrowAppClient.getIntegerState(state, "asset_listed");
+      },
+      get feeTimerStart() {
+        return _EscrowAppClient.getIntegerState(state, "fee_timer_start");
+      },
+      get marketAppId() {
+        return _EscrowAppClient.getIntegerState(state, "market_app_id");
+      },
+      get owner() {
+        return _EscrowAppClient.getBinaryState(state, "owner");
+      },
+      get position() {
+        return _EscrowAppClient.getIntegerState(state, "position");
+      },
+      get price() {
+        return _EscrowAppClient.getIntegerState(state, "price");
+      },
+      get quantity() {
+        return _EscrowAppClient.getIntegerState(state, "quantity");
+      },
+      get quantityFilled() {
+        return _EscrowAppClient.getIntegerState(state, "quantity_filled");
+      },
+      get side() {
+        return _EscrowAppClient.getIntegerState(state, "side");
+      },
+      get slippage() {
+        return _EscrowAppClient.getIntegerState(state, "slippage");
+      }
+    };
+  }
+  compose() {
+    const client = this;
+    const atc = new AtomicTransactionComposer();
+    let promiseChain = Promise.resolve();
+    const resultMappers = [];
+    return {
+      setup(args, params) {
+        promiseChain = promiseChain.then(() => client.setup(args, { ...params, sendParams: { ...params?.sendParams, skipSending: true, atc } }));
+        resultMappers.push(void 0);
+        return this;
+      },
+      matchMaker(args, params) {
+        promiseChain = promiseChain.then(() => client.matchMaker(args, { ...params, sendParams: { ...params?.sendParams, skipSending: true, atc } }));
+        resultMappers.push(void 0);
+        return this;
+      },
+      amendOrder(args, params) {
+        promiseChain = promiseChain.then(() => client.amendOrder(args, { ...params, sendParams: { ...params?.sendParams, skipSending: true, atc } }));
+        resultMappers.push(void 0);
+        return this;
+      },
+      matchTaker(args, params) {
+        promiseChain = promiseChain.then(() => client.matchTaker(args, { ...params, sendParams: { ...params?.sendParams, skipSending: true, atc } }));
+        resultMappers.push(void 0);
+        return this;
+      },
+      get update() {
+        const $this = this;
+        return {
+          onUpdate(args, params) {
+            promiseChain = promiseChain.then(() => client.update.onUpdate(args, { ...params, sendParams: { ...params?.sendParams, skipSending: true, atc } }));
+            resultMappers.push(void 0);
+            return $this;
+          }
+        };
+      },
+      get delete() {
+        const $this = this;
+        return {
+          delete(args, params) {
+            promiseChain = promiseChain.then(() => client.delete.delete(args, { ...params, sendParams: { ...params?.sendParams, skipSending: true, atc } }));
+            resultMappers.push(void 0);
+            return $this;
+          }
+        };
+      },
+      clearState(args) {
+        promiseChain = promiseChain.then(() => client.clearState({ ...args, sendParams: { ...args?.sendParams, skipSending: true, atc } }));
+        resultMappers.push(void 0);
+        return this;
+      },
+      addTransaction(txn, defaultSender) {
+        promiseChain = promiseChain.then(async () => atc.addTransaction(await algokit4.getTransactionWithSigner(txn, defaultSender ?? client.sender)));
+        return this;
+      },
+      async atc() {
+        await promiseChain;
+        return atc;
+      },
+      async simulate(options) {
+        await promiseChain;
+        const result = await atc.simulate(client.algod, new modelsv2.SimulateRequest({ txnGroups: [], ...options }));
+        return {
+          ...result,
+          returns: result.methodResults?.map((val, i) => resultMappers[i] !== void 0 ? resultMappers[i](val.returnValue) : val.returnValue)
+        };
+      },
+      async execute(sendParams) {
+        await promiseChain;
+        const result = await algokit4.sendAtomicTransactionComposer({ atc, sendParams }, client.algod);
         return {
           ...result,
           returns: result.returns?.map((val, i) => resultMappers[i] !== void 0 ? resultMappers[i](val.returnValue) : val.returnValue)
@@ -1634,7 +2320,7 @@ var createOrder = async (config, params) => {
   if (!isBuying) {
     const hasUsdcOptIn = await checkAssetOptIn(algodClient, activeAddress, usdcAssetId);
     if (!hasUsdcOptIn) {
-      const optInTxn = await algokit3.transferAsset(
+      const optInTxn = await algokit4.transferAsset(
         { from: signerAccount, to: activeAddress, assetId: usdcAssetId, amount: 0, skipSending: true },
         algodClient
       );
@@ -1645,7 +2331,7 @@ var createOrder = async (config, params) => {
     const assetId = position === 1 ? yesAssetId : noAssetId;
     const hasAssetOptIn = await checkAssetOptIn(algodClient, activeAddress, assetId);
     if (!hasAssetOptIn) {
-      const optInTxn = await algokit3.transferAsset(
+      const optInTxn = await algokit4.transferAsset(
         { from: signerAccount, to: activeAddress, assetId, amount: 0, skipSending: true },
         algodClient
       );
@@ -1653,15 +2339,15 @@ var createOrder = async (config, params) => {
       createEscrowTxnIndex++;
     }
   }
-  const paymentTxn = await algokit3.transferAlgos(
-    { from: signerAccount, to: marketAddress, amount: algokit3.microAlgos(957e3), skipSending: true },
+  const paymentTxn = await algokit4.transferAlgos(
+    { from: signerAccount, to: marketAddress, amount: algokit4.microAlgos(957e3), skipSending: true },
     algodClient
   );
   atc.addTransaction({ txn: paymentTxn.transaction, signer });
   createEscrowTxnIndex++;
   const fundAmount = isBuying ? Math.floor(quantity * (price + slippage) / 1e6) + fee : quantity;
   const fundAssetId = isBuying ? usdcAssetId : position === 1 ? yesAssetId : noAssetId;
-  const assetTransferTxn = await algokit3.transferAsset(
+  const assetTransferTxn = await algokit4.transferAsset(
     { from: signerAccount, to: marketAddress, amount: fundAmount, assetId: fundAssetId, skipSending: true },
     algodClient
   );
@@ -1674,11 +2360,11 @@ var createOrder = async (config, params) => {
   atc.addTransaction({ txn: createEscrowTxn.transaction, signer });
   let matchIndex = 1;
   for (const matchingOrder of matchingOrders) {
-    const payCounterPartyTxn = await algokit3.transferAlgos(
+    const payCounterPartyTxn = await algokit4.transferAlgos(
       {
         from: signerAccount,
         to: getApplicationAddress(matchingOrder.escrowAppId),
-        amount: algokit3.microAlgos(1e3 * (isBuying ? 1 : 2)),
+        amount: algokit4.microAlgos(1e3 * (isBuying ? 1 : 2)),
         skipSending: true
       },
       algodClient
@@ -1697,7 +2383,7 @@ var createOrder = async (config, params) => {
       {
         assets: [usdcAssetId, yesAssetId, noAssetId],
         accounts: [activeAddress, marketFeeAddress, matchingOrder.owner],
-        sendParams: { skipSending: true, fee: algokit3.microAlgos(1e4) }
+        sendParams: { skipSending: true, fee: algokit4.microAlgos(1e4) }
       }
     );
     atc.addTransaction({ txn: proposeAMatchTxn.transaction, signer });
@@ -1730,7 +2416,7 @@ var cancelOrder = async (config, params) => {
       apps: [escrowAppId],
       assets: [usdcAssetId, yesAssetId, noAssetId],
       accounts: [orderOwner],
-      sendParams: { skipSending: true, fee: algokit3.microAlgos(7e3) }
+      sendParams: { skipSending: true, fee: algokit4.microAlgos(7e3) }
     }
   );
   atc.addTransaction({ txn: deleteCallTxn.transaction, signer });
@@ -1754,11 +2440,11 @@ var proposeMatch = async (config, params) => {
     algodClient
   );
   const atc = new AtomicTransactionComposer();
-  const payMakerTxn = await algokit3.transferAlgos(
+  const payMakerTxn = await algokit4.transferAlgos(
     {
       from: signerAccount,
       to: getApplicationAddress(makerEscrowAppId),
-      amount: algokit3.microAlgos(2e3),
+      amount: algokit4.microAlgos(2e3),
       skipSending: true
     },
     algodClient
@@ -1777,7 +2463,7 @@ var proposeMatch = async (config, params) => {
     {
       assets: [usdcAssetId, yesAssetId, noAssetId],
       accounts: [activeAddress, marketFeeAddress, makerAddress],
-      sendParams: { skipSending: true, fee: algokit3.microAlgos(1e4) }
+      sendParams: { skipSending: true, fee: algokit4.microAlgos(1e4) }
     }
   );
   atc.addTransaction({ txn: proposeTxn.transaction, signer });
@@ -1788,6 +2474,68 @@ var proposeMatch = async (config, params) => {
     confirmedRound: result.confirmedRound
   };
 };
+var amendOrder = async (config, params) => {
+  const { algodClient, signer, activeAddress, usdcAssetId } = config;
+  const { marketAppId, escrowAppId, price, quantity, slippage = 0 } = params;
+  const escrowAppInfo = await algodClient.getApplicationByID(escrowAppId).do();
+  const escrowState = decodeGlobalState(
+    escrowAppInfo.params?.["global-state"] ?? escrowAppInfo["params"]?.["global-state"] ?? []
+  );
+  if ((escrowState.quantity_filled ?? 0) > 0) {
+    throw new Error("Cannot amend an order that has been partially or fully filled.");
+  }
+  const globalState = await getMarketGlobalState(algodClient, marketAppId);
+  const yesAssetId = globalState.yes_asset_id;
+  const noAssetId = globalState.no_asset_id;
+  const feeBase = globalState.fee_base_percent;
+  const isBuy = escrowState.side === 1;
+  const position = escrowState.position;
+  const computeCollateral = (qty, px, slip) => {
+    if (isBuy) {
+      const fee = calculateFee(qty, px + slip, feeBase);
+      return Math.floor(qty * (px + slip) / 1e6) + fee;
+    }
+    return qty;
+  };
+  const oldCollateral = computeCollateral(
+    escrowState.quantity ?? 0,
+    escrowState.price ?? 0,
+    escrowState.slippage ?? 0
+  );
+  const newCollateral = computeCollateral(quantity, price, slippage);
+  const delta = newCollateral - oldCollateral;
+  const fundAssetId = isBuy ? usdcAssetId : position === 1 ? yesAssetId : noAssetId;
+  const escrowAddr = getApplicationAddress(escrowAppId).toString();
+  const signerAccount = { signer, addr: activeAddress };
+  const atc = new AtomicTransactionComposer();
+  if (delta > 0) {
+    const fundTxn = await algokit4.transferAsset(
+      { from: signerAccount, to: escrowAddr, amount: delta, assetId: fundAssetId, skipSending: true },
+      algodClient
+    );
+    atc.addTransaction({ txn: fundTxn.transaction, signer });
+  }
+  const escrowClient = new EscrowAppClient(
+    { resolveBy: "id", id: escrowAppId, sender: signerAccount },
+    algodClient
+  );
+  const feeMicros = delta <= 0 ? 2e3 : 1e3;
+  const amendCall = await escrowClient.amendOrder(
+    { price, quantity, slippage },
+    {
+      assets: [usdcAssetId, yesAssetId, noAssetId],
+      apps: [marketAppId],
+      sendParams: { fee: algokit4.microAlgos(feeMicros), skipSending: true }
+    }
+  );
+  atc.addTransaction({ txn: amendCall.transaction, signer });
+  const result = await atc.execute(algodClient, 4);
+  return {
+    success: true,
+    txIds: result.txIDs,
+    confirmedRound: result.confirmedRound
+  };
+};
 var splitShares = async (config, params) => {
   const { algodClient, signer, activeAddress, usdcAssetId } = config;
   const { marketAppId, amount } = params;
@@ -1804,7 +2552,7 @@ var splitShares = async (config, params) => {
   let optInCosts = 0;
   const hasYesOptIn = await checkAssetOptIn(algodClient, activeAddress, yesAssetId);
   if (!hasYesOptIn) {
-    const optInTxn = await algokit3.transferAsset(
+    const optInTxn = await algokit4.transferAsset(
       { from: signerAccount, to: activeAddress, assetId: yesAssetId, amount: 0, skipSending: true },
       algodClient
     );
@@ -1813,19 +2561,19 @@ var splitShares = async (config, params) => {
   }
   const hasNoOptIn = await checkAssetOptIn(algodClient, activeAddress, noAssetId);
   if (!hasNoOptIn) {
-    const optInTxn = await algokit3.transferAsset(
+    const optInTxn = await algokit4.transferAsset(
       { from: signerAccount, to: activeAddress, assetId: noAssetId, amount: 0, skipSending: true },
       algodClient
     );
     atc.addTransaction({ txn: optInTxn.transaction, signer });
     optInCosts += 1e3;
   }
-  const algoPayment = await algokit3.transferAlgos(
-    { from: signerAccount, to: marketAddress, amount: algokit3.microAlgos(5e3 + optInCosts), skipSending: true },
+  const algoPayment = await algokit4.transferAlgos(
+    { from: signerAccount, to: marketAddress, amount: algokit4.microAlgos(5e3 + optInCosts), skipSending: true },
     algodClient
   );
   atc.addTransaction({ txn: algoPayment.transaction, signer });
-  const usdcTransfer = await algokit3.transferAsset(
+  const usdcTransfer = await algokit4.transferAsset(
     { from: signerAccount, to: marketAddress, amount, assetId: usdcAssetId, skipSending: true },
     algodClient
   );
@@ -1858,24 +2606,24 @@ var mergeShares = async (config, params) => {
   let optInCosts = 0;
   const hasUsdcOptIn = await checkAssetOptIn(algodClient, activeAddress, usdcAssetId);
   if (!hasUsdcOptIn) {
-    const optInTxn = await algokit3.transferAsset(
+    const optInTxn = await algokit4.transferAsset(
       { from: signerAccount, to: activeAddress, assetId: usdcAssetId, amount: 0, skipSending: true },
       algodClient
     );
     atc.addTransaction({ txn: optInTxn.transaction, signer });
     optInCosts += 1e3;
   }
-  const algoPayment = await algokit3.transferAlgos(
-    { from: signerAccount, to: marketAddress, amount: algokit3.microAlgos(5e3 + optInCosts), skipSending: true },
+  const algoPayment = await algokit4.transferAlgos(
+    { from: signerAccount, to: marketAddress, amount: algokit4.microAlgos(5e3 + optInCosts), skipSending: true },
     algodClient
   );
   atc.addTransaction({ txn: algoPayment.transaction, signer });
-  const yesTransfer = await algokit3.transferAsset(
+  const yesTransfer = await algokit4.transferAsset(
     { from: signerAccount, to: marketAddress, amount, assetId: yesAssetId, skipSending: true },
     algodClient
   );
   atc.addTransaction({ txn: yesTransfer.transaction, signer });
-  const noTransfer = await algokit3.transferAsset(
+  const noTransfer = await algokit4.transferAsset(
     { from: signerAccount, to: marketAddress, amount, assetId: noAssetId, skipSending: true },
     algodClient
   );
@@ -1912,7 +2660,7 @@ var claim = async (config, params) => {
     throw new Error("No tokens to claim");
   }
   const atc = new AtomicTransactionComposer();
-  const tokenTransfer = await algokit3.transferAsset(
+  const tokenTransfer = await algokit4.transferAsset(
     { from: signerAccount, to: marketAddress, amount: tokenBalance, assetId, skipSending: true },
     algodClient
   );
@@ -1921,7 +2669,7 @@ var claim = async (config, params) => {
     {},
     {
       assets: [usdcAssetId, assetId],
-      sendParams: { skipSending: true, fee: algokit3.microAlgos(1e3) }
+      sendParams: { skipSending: true, fee: algokit4.microAlgos(1e3) }
     }
   );
   atc.addTransaction({ txn: claimTxn.transaction, signer });
@@ -2259,6 +3007,21 @@ var AlphaClient = class {
   async proposeMatch(params) {
     return proposeMatch(this.config, params);
   }
+  /**
+   * Amends (edits) an existing unfilled order in-place.
+   *
+   * Cheaper and faster than cancel + recreate. The escrow contract adjusts
+   * collateral automatically — sends you a refund if the new value is lower,
+   * or requires extra funds if higher.
+   *
+   * Only works on orders with zero quantity filled.
+   *
+   * @param params - Amend parameters (marketAppId, escrowAppId, price, quantity, slippage?)
+   * @returns Whether the amendment succeeded
+   */
+  async amendOrder(params) {
+    return amendOrder(this.config, params);
+  }
   // ============================================
   // Positions
   // ============================================