diff --git a/batcher/Makefile b/batcher/Makefile
index 280612ea..d03a58de 100644
--- a/batcher/Makefile
+++ b/batcher/Makefile
@@ -109,8 +109,8 @@ build-EURL:
 build-fa12-tzBTC:
 	$(call compile_contract,$(FA12_DIRECTORY)/main.mligo, $(MICHELSON_DIRECTORY)/tzBTC_fa12_token.tz)
 	$(call compile_storage,$(FA12_STORAGE_DIRECTORY)/tzBTC_storage.mligo, $(MICHELSON_DIRECTORY)/tzBTC_fa12_token_storage.tz)
-build-all-ghostnet: build-tm-ghostnet build-btctz-vault-ghostnet build-eurl-vault-ghostnet build-usdt-vault-ghostnet build-btctz-vault-ghostnet build-usdtz-vault-ghostnet build-mm-ghostnet build-batcher-ghostnet
-build-all-mainnet: build-tm-mainnet build-btctz-vault-mainnet build-eurl-vault-mainnet build-usdt-vault-mainnet build-btctz-vault-mainnet build-usdtz-vault-mainnet build-mm-mainnet build-batcher-mainnet
+build-all-ghostnet: build-tm-ghostnet build-tzbtc-vault-ghostnet build-eurl-vault-ghostnet build-usdt-vault-ghostnet build-btctz-vault-ghostnet build-usdtz-vault-ghostnet build-mm-ghostnet build-batcher-ghostnet
+build-all-mainnet: build-tm-mainnet build-tzbtc-vault-mainnet build-eurl-vault-mainnet build-usdt-vault-mainnet build-btctz-vault-mainnet build-usdtz-vault-mainnet build-mm-mainnet build-batcher-mainnet
 test-mm:
 	$(call test_ligo,$(TEST_DIRECTORY)/test-market-maker.mligo)
 test-tm:
diff --git a/batcher/michelson/tzbtc-vault-ghostnet.tz b/batcher/michelson/tzbtc-vault-ghostnet.tz
new file mode 100644
index 00000000..67557279
--- /dev/null
+++ b/batcher/michelson/tzbtc-vault-ghostnet.tz
@@ -0,0 +1,1136 @@
+{ parameter
+    (or (or (or (or (nat %addLiquidity) (mutez %addReward))
+                (or (address %change_admin_address) (address %change_batcher_address)))
+            (or (or (address %change_marketmaker_address) (address %change_tokenmanager_address))
+                (or (unit %claim)
+                    (pair %injectLiquidity
+                       (pair (nat %amount)
+                             (pair %from_token
+                                (nat %token_id)
+                                (string %name)
+                                (option %address address)
+                                (nat %decimals)
+                                (option %standard string)))
+                       (or %side (unit %buy) (unit %sell))
+                       (pair %to_token
+                          (nat %token_id)
+                          (string %name)
+                          (option %address address)
+                          (nat %decimals)
+                          (option %standard string))))))
+        (unit %removeLiquidity)) ;
+  storage
+    (pair (pair (pair (address %administrator) (address %batcher))
+                (map %foreign_tokens
+                   string
+                   (pair (pair %token
+                            (nat %token_id)
+                            (string %name)
+                            (option %address address)
+                            (nat %decimals)
+                            (option %standard string))
+                         (nat %amount)))
+                (address %marketmaker))
+          (pair (pair %native_token
+                   (pair %token
+                      (nat %token_id)
+                      (string %name)
+                      (option %address address)
+                      (nat %decimals)
+                      (option %standard string))
+                   (nat %amount))
+                (address %tokenmanager))
+          (nat %total_shares)
+          (pair %vault_holdings
+             (set %keys address)
+             (big_map %values
+                address
+                (pair (pair (address %holder) (nat %shares)) (mutez %unclaimed))))) ;
+  code { LAMBDA
+           (pair (pair (pair nat string (option address) nat (option string)) nat)
+                 (map string (pair (pair nat string (option address) nat (option string)) nat)))
+           (map string (pair (pair nat string (option address) nat (option string)) nat))
+           { UNPAIR ;
+             SWAP ;
+             UNIT ;
+             RIGHT unit ;
+             DIG 2 ;
+             DUP ;
+             CAR ;
+             GET 3 ;
+             DUP 4 ;
+             DUP 2 ;
+             GET ;
+             IF_NONE
+               { DIG 2 ; DROP ; SWAP ; SOME ; SWAP ; UPDATE }
+               { DIG 3 ;
+                 IF_LEFT
+                   { DROP ;
+                     DUP ;
+                     CDR ;
+                     DUP 4 ;
+                     CDR ;
+                     COMPARE ;
+                     GT ;
+                     IF { DROP ; PUSH nat 111 ; FAILWITH }
+                        { DUP 3 ; CDR ; SWAP ; CDR ; SUB ; ABS } }
+                   { DROP ; CDR ; DUP 3 ; CDR ; ADD } ;
+                 DIG 3 ;
+                 DIG 3 ;
+                 DIG 2 ;
+                 UPDATE 2 ;
+                 SOME ;
+                 DIG 2 ;
+                 UPDATE } } ;
+         LAMBDA
+           (pair (lambda
+                    (pair (pair (pair nat string (option address) nat (option string)) nat)
+                          (map string (pair (pair nat string (option address) nat (option string)) nat)))
+                    (map string (pair (pair nat string (option address) nat (option string)) nat)))
+                 (pair (pair int int)
+                       (pair (pair nat string (option address) nat (option string)) nat)
+                       (map string (pair (pair nat string (option address) nat (option string)) nat))))
+           (pair (pair (pair nat string (option address) nat (option string)) nat)
+                 (map string (pair (pair nat string (option address) nat (option string)) nat)))
+           { UNPAIR ;
+             SWAP ;
+             UNPAIR 3 ;
+             DUP 2 ;
+             CDR ;
+             INT ;
+             PUSH int 1 ;
+             SWAP ;
+             PAIR ;
+             DUP ;
+             CDR ;
+             DUP 3 ;
+             CDR ;
+             MUL ;
+             SWAP ;
+             CAR ;
+             DIG 2 ;
+             CAR ;
+             MUL ;
+             PAIR ;
+             PUSH int 0 ;
+             DUP 2 ;
+             CAR ;
+             COMPARE ;
+             LT ;
+             IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR }
+                {} ;
+             DUP ;
+             CDR ;
+             PUSH nat 1 ;
+             PUSH nat 0 ;
+             PUSH nat 10 ;
+             PAIR ;
+             PAIR ;
+             LEFT nat ;
+             LOOP_LEFT
+               { UNPAIR ;
+                 UNPAIR ;
+                 PUSH nat 0 ;
+                 DUP 3 ;
+                 COMPARE ;
+                 EQ ;
+                 IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) }
+                    { PUSH nat 1 ;
+                      PUSH nat 1 ;
+                      DUP 4 ;
+                      AND ;
+                      COMPARE ;
+                      EQ ;
+                      IF { DUP ; DIG 3 ; MUL } { DIG 2 } ;
+                      PUSH nat 1 ;
+                      DIG 3 ;
+                      LSR ;
+                      DUP 3 ;
+                      DIG 3 ;
+                      MUL ;
+                      PAIR ;
+                      PAIR ;
+                      LEFT nat } } ;
+             DIG 2 ;
+             CAR ;
+             MUL ;
+             EDIV ;
+             IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
+             CAR ;
+             ISNAT ;
+             IF_NONE { PUSH nat 119 ; FAILWITH } {} ;
+             DUP 2 ;
+             CDR ;
+             DUP 2 ;
+             COMPARE ;
+             GT ;
+             IF { DROP 4 ; PUSH nat 153 ; FAILWITH }
+                { DUP ;
+                  DUP 3 ;
+                  CDR ;
+                  INT ;
+                  SUB ;
+                  ABS ;
+                  DUP 3 ;
+                  DIG 2 ;
+                  UPDATE 2 ;
+                  PUSH nat 0 ;
+                  DUP 2 ;
+                  CDR ;
+                  COMPARE ;
+                  EQ ;
+                  IF { DIG 4 ; DROP 2 ; DIG 2 }
+                     { DIG 3 ; SWAP ; PAIR ; DIG 3 ; SWAP ; EXEC } ;
+                  DUG 2 ;
+                  UPDATE 2 ;
+                  PAIR } } ;
+         DUP 2 ;
+         APPLY ;
+         DIG 2 ;
+         UNPAIR ;
+         IF_LEFT
+           { DIG 2 ;
+             DIG 3 ;
+             DROP 2 ;
+             IF_LEFT
+               { IF_LEFT
+                   { IF_LEFT
+                       { PUSH mutez 1 ;
+                         AMOUNT ;
+                         COMPARE ;
+                         LT ;
+                         IF {} { PUSH nat 118 ; FAILWITH } ;
+                         SENDER ;
+                         DUP 3 ;
+                         CDR ;
+                         CAR ;
+                         CAR ;
+                         DIG 2 ;
+                         UPDATE 2 ;
+                         SELF_ADDRESS ;
+                         DUP 2 ;
+                         CAR ;
+                         GET 5 ;
+                         IF_NONE
+                           { DROP ; PUSH nat 109 ; FAILWITH }
+                           { DUP 3 ;
+                             CAR ;
+                             GET 8 ;
+                             IF_NONE
+                               { DROP 2 ; PUSH nat 108 ; FAILWITH }
+                               { PUSH string "FA1.2 token" ;
+                                 DUP 2 ;
+                                 COMPARE ;
+                                 EQ ;
+                                 IF { DROP ;
+                                      CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ;
+                                      IF_NONE { PUSH nat 101 ; FAILWITH } {} ;
+                                      PUSH mutez 0 ;
+                                      DUP 4 ;
+                                      CDR ;
+                                      DIG 3 ;
+                                      DUP 6 ;
+                                      PAIR 3 ;
+                                      TRANSFER_TOKENS }
+                                    { PUSH string "FA2 token" ;
+                                      SWAP ;
+                                      COMPARE ;
+                                      EQ ;
+                                      IF { CONTRACT %transfer
+                                             (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ;
+                                           IF_NONE { PUSH nat 101 ; FAILWITH } {} ;
+                                           PUSH mutez 0 ;
+                                           NIL (pair address (list (pair address nat nat))) ;
+                                           NIL (pair address nat nat) ;
+                                           DUP 6 ;
+                                           CDR ;
+                                           DUP 7 ;
+                                           CAR ;
+                                           CAR ;
+                                           DIG 6 ;
+                                           PAIR 3 ;
+                                           CONS ;
+                                           DUP 6 ;
+                                           PAIR ;
+                                           CONS ;
+                                           TRANSFER_TOKENS }
+                                         { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ;
+                         DUP 4 ;
+                         CDR ;
+                         CAR ;
+                         CAR ;
+                         DUP ;
+                         CAR ;
+                         DUP 4 ;
+                         CAR ;
+                         DUP 2 ;
+                         GET 8 ;
+                         DUP 2 ;
+                         GET 8 ;
+                         COMPARE ;
+                         EQ ;
+                         DUP 3 ;
+                         GET 7 ;
+                         DUP 3 ;
+                         GET 7 ;
+                         COMPARE ;
+                         EQ ;
+                         DUP 4 ;
+                         GET 5 ;
+                         DUP 4 ;
+                         GET 5 ;
+                         COMPARE ;
+                         EQ ;
+                         DUP 5 ;
+                         GET 3 ;
+                         DUP 5 ;
+                         GET 3 ;
+                         COMPARE ;
+                         EQ ;
+                         DIG 5 ;
+                         CAR ;
+                         DIG 5 ;
+                         CAR ;
+                         COMPARE ;
+                         EQ ;
+                         AND ;
+                         AND ;
+                         AND ;
+                         AND ;
+                         NOT ;
+                         IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 4 ; PUSH nat 115 ; FAILWITH }
+                            { DUP 3 ;
+                              CDR ;
+                              DUP 6 ;
+                              CDR ;
+                              CDR ;
+                              CAR ;
+                              ADD ;
+                              DUP 2 ;
+                              DUP 5 ;
+                              CDR ;
+                              DIG 3 ;
+                              CDR ;
+                              ADD ;
+                              UPDATE 2 ;
+                              DUP 6 ;
+                              CDR ;
+                              CDR ;
+                              CDR ;
+                              DUP ;
+                              CAR ;
+                              DUP 7 ;
+                              MEM ;
+                              IF { CDR ;
+                                   DUP 6 ;
+                                   GET ;
+                                   IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } }
+                                 { DROP ; NONE (pair (pair address nat) mutez) } ;
+                              IF_NONE
+                                { PUSH mutez 0 ; DIG 4 ; CDR ; DUP 6 ; PAIR ; PAIR }
+                                { DIG 4 ;
+                                  CDR ;
+                                  DUP 2 ;
+                                  CAR ;
+                                  CDR ;
+                                  ADD ;
+                                  DUP 2 ;
+                                  DIG 2 ;
+                                  CAR ;
+                                  DIG 2 ;
+                                  UPDATE 2 ;
+                                  UPDATE 1 } ;
+                              DUP 6 ;
+                              DUP 7 ;
+                              CDR ;
+                              DUP ;
+                              CDR ;
+                              DIG 5 ;
+                              UPDATE 1 ;
+                              UPDATE 2 ;
+                              UPDATE 2 ;
+                              DUP ;
+                              CDR ;
+                              DUP ;
+                              CDR ;
+                              DIG 7 ;
+                              CDR ;
+                              CDR ;
+                              CDR ;
+                              DUP ;
+                              CAR ;
+                              DUP 9 ;
+                              MEM ;
+                              IF { DUP ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 }
+                                 { DUP ;
+                                   DUP 2 ;
+                                   CAR ;
+                                   DUP 10 ;
+                                   PUSH bool True ;
+                                   SWAP ;
+                                   UPDATE ;
+                                   UPDATE 1 ;
+                                   SWAP ;
+                                   CDR ;
+                                   DIG 5 ;
+                                   DIG 8 ;
+                                   SWAP ;
+                                   SOME ;
+                                   SWAP ;
+                                   UPDATE ;
+                                   UPDATE 2 } ;
+                              UPDATE 2 ;
+                              UPDATE 2 ;
+                              UPDATE 2 ;
+                              DUP ;
+                              CDR ;
+                              DUP ;
+                              CAR ;
+                              DIG 3 ;
+                              UPDATE 1 ;
+                              UPDATE 1 ;
+                              UPDATE 2 } ;
+                         NIL operation ;
+                         DIG 2 ;
+                         CONS }
+                       { DUP 2 ;
+                         CDR ;
+                         CDR ;
+                         CAR ;
+                         INT ;
+                         PUSH int 1 ;
+                         SWAP ;
+                         PAIR ;
+                         PUSH mutez 1 ;
+                         DIG 2 ;
+                         EDIV ;
+                         IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
+                         CAR ;
+                         INT ;
+                         PUSH int 1 ;
+                         SWAP ;
+                         PAIR ;
+                         DUP 3 ;
+                         CDR ;
+                         CDR ;
+                         CDR ;
+                         EMPTY_MAP address (pair (pair address nat) mutez) ;
+                         DUP 2 ;
+                         CAR ;
+                         ITER { SWAP ;
+                                DUP 3 ;
+                                CDR ;
+                                DUP 3 ;
+                                GET ;
+                                IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ;
+                         SWAP ;
+                         DROP ;
+                         EMPTY_BIG_MAP address (pair (pair address nat) mutez) ;
+                         EMPTY_SET address ;
+                         PAIR ;
+                         SWAP ;
+                         ITER { UNPAIR ;
+                                DUP 2 ;
+                                CAR ;
+                                CDR ;
+                                INT ;
+                                PUSH int 1 ;
+                                SWAP ;
+                                PAIR ;
+                                DUP 6 ;
+                                CAR ;
+                                DUP 2 ;
+                                CDR ;
+                                MUL ;
+                                DUP 7 ;
+                                CDR ;
+                                DIG 2 ;
+                                CAR ;
+                                MUL ;
+                                PAIR ;
+                                DUP 5 ;
+                                CDR ;
+                                DUP 2 ;
+                                CDR ;
+                                MUL ;
+                                DUP 6 ;
+                                CAR ;
+                                DIG 2 ;
+                                CAR ;
+                                MUL ;
+                                PAIR ;
+                                PUSH int 0 ;
+                                DUP 2 ;
+                                CAR ;
+                                COMPARE ;
+                                LT ;
+                                IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR }
+                                   {} ;
+                                DUP ;
+                                CDR ;
+                                PUSH nat 1 ;
+                                PUSH nat 0 ;
+                                PUSH nat 10 ;
+                                PAIR ;
+                                PAIR ;
+                                LEFT nat ;
+                                LOOP_LEFT
+                                  { UNPAIR ;
+                                    UNPAIR ;
+                                    PUSH nat 0 ;
+                                    DUP 3 ;
+                                    COMPARE ;
+                                    EQ ;
+                                    IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) }
+                                       { PUSH nat 1 ;
+                                         PUSH nat 1 ;
+                                         DUP 4 ;
+                                         AND ;
+                                         COMPARE ;
+                                         EQ ;
+                                         IF { DUP ; DIG 3 ; MUL } { DIG 2 } ;
+                                         PUSH nat 1 ;
+                                         DIG 3 ;
+                                         LSR ;
+                                         DUP 3 ;
+                                         DIG 3 ;
+                                         MUL ;
+                                         PAIR ;
+                                         PAIR ;
+                                         LEFT nat } } ;
+                                DIG 2 ;
+                                CAR ;
+                                MUL ;
+                                EDIV ;
+                                IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ;
+                                CAR ;
+                                ISNAT ;
+                                IF_NONE { PUSH nat 119 ; FAILWITH } {} ;
+                                PUSH mutez 1 ;
+                                MUL ;
+                                PUSH mutez 0 ;
+                                DUP 2 ;
+                                COMPARE ;
+                                GT ;
+                                IF { DUP 3 ; CDR ; ADD } { DROP ; DUP 2 ; CDR } ;
+                                DIG 2 ;
+                                SWAP ;
+                                UPDATE 2 ;
+                                DUP 3 ;
+                                CAR ;
+                                DUP 3 ;
+                                MEM ;
+                                IF { DUP 3 ; DIG 3 ; CDR ; DIG 2 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 }
+                                   { DUP 3 ;
+                                     DUP 4 ;
+                                     CAR ;
+                                     DUP 4 ;
+                                     PUSH bool True ;
+                                     SWAP ;
+                                     UPDATE ;
+                                     UPDATE 1 ;
+                                     DIG 3 ;
+                                     CDR ;
+                                     DIG 2 ;
+                                     DIG 3 ;
+                                     SWAP ;
+                                     SOME ;
+                                     SWAP ;
+                                     UPDATE ;
+                                     UPDATE 2 } } ;
+                         SWAP ;
+                         DIG 2 ;
+                         DROP 2 ;
+                         DUP 2 ;
+                         DIG 2 ;
+                         CDR ;
+                         DUP ;
+                         CDR ;
+                         DIG 3 ;
+                         UPDATE 2 ;
+                         UPDATE 2 ;
+                         UPDATE 2 ;
+                         NIL operation } }
+                   { IF_LEFT
+                       { DUP 2 ;
+                         CAR ;
+                         CAR ;
+                         CAR ;
+                         SENDER ;
+                         COMPARE ;
+                         EQ ;
+                         IF {} { PUSH nat 114 ; FAILWITH } ;
+                         PUSH mutez 1 ;
+                         AMOUNT ;
+                         COMPARE ;
+                         LT ;
+                         IF {} { PUSH nat 118 ; FAILWITH } ;
+                         DUP 2 ;
+                         DIG 2 ;
+                         CAR ;
+                         DUP ;
+                         CAR ;
+                         DIG 3 ;
+                         UPDATE 1 ;
+                         UPDATE 1 ;
+                         UPDATE 1 }
+                       { DUP 2 ;
+                         CAR ;
+                         CAR ;
+                         CAR ;
+                         SENDER ;
+                         COMPARE ;
+                         EQ ;
+                         IF {} { PUSH nat 114 ; FAILWITH } ;
+                         PUSH mutez 1 ;
+                         AMOUNT ;
+                         COMPARE ;
+                         LT ;
+                         IF {} { PUSH nat 118 ; FAILWITH } ;
+                         DUP 2 ;
+                         DIG 2 ;
+                         CAR ;
+                         DUP ;
+                         CAR ;
+                         DIG 3 ;
+                         UPDATE 2 ;
+                         UPDATE 1 ;
+                         UPDATE 1 } ;
+                     NIL operation } ;
+                 PAIR }
+               { IF_LEFT
+                   { IF_LEFT
+                       { DUP 2 ;
+                         CAR ;
+                         CAR ;
+                         CAR ;
+                         SENDER ;
+                         COMPARE ;
+                         EQ ;
+                         IF {} { PUSH nat 114 ; FAILWITH } ;
+                         PUSH mutez 1 ;
+                         AMOUNT ;
+                         COMPARE ;
+                         LT ;
+                         IF {} { PUSH nat 118 ; FAILWITH } ;
+                         DUP 2 ;
+                         DIG 2 ;
+                         CAR ;
+                         DUP ;
+                         CDR ;
+                         DIG 3 ;
+                         UPDATE 2 ;
+                         UPDATE 2 ;
+                         UPDATE 1 }
+                       { DUP 2 ;
+                         CAR ;
+                         CAR ;
+                         CAR ;
+                         SENDER ;
+                         COMPARE ;
+                         EQ ;
+                         IF {} { PUSH nat 114 ; FAILWITH } ;
+                         PUSH mutez 1 ;
+                         AMOUNT ;
+                         COMPARE ;
+                         LT ;
+                         IF {} { PUSH nat 118 ; FAILWITH } ;
+                         DUP 2 ;
+                         DIG 2 ;
+                         CDR ;
+                         DUP ;
+                         CAR ;
+                         DIG 3 ;
+                         UPDATE 2 ;
+                         UPDATE 1 ;
+                         UPDATE 2 } ;
+                     NIL operation ;
+                     PAIR }
+                   { IF_LEFT
+                       { DROP ;
+                         PUSH mutez 1 ;
+                         AMOUNT ;
+                         COMPARE ;
+                         LT ;
+                         IF {} { PUSH nat 118 ; FAILWITH } ;
+                         SENDER ;
+                         DUP 2 ;
+                         CDR ;
+                         CDR ;
+                         CDR ;
+                         DUP ;
+                         CAR ;
+                         DUP 3 ;
+                         MEM ;
+                         IF { CDR ;
+                              SWAP ;
+                              GET ;
+                              IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } }
+                            { DROP 2 ; NONE (pair (pair address nat) mutez) } ;
+                         IF_NONE
+                           { DROP ; PUSH nat 155 ; FAILWITH }
+                           { DUP ;
+                             CDR ;
+                             PUSH mutez 0 ;
+                             DUP 2 ;
+                             COMPARE ;
+                             EQ ;
+                             IF { DROP 3 ; PUSH nat 155 ; FAILWITH }
+                                { SWAP ;
+                                  PUSH mutez 0 ;
+                                  UPDATE 2 ;
+                                  DUP ;
+                                  CAR ;
+                                  CAR ;
+                                  CONTRACT unit ;
+                                  IF_NONE
+                                    { SWAP ; DROP ; PUSH nat 102 ; FAILWITH }
+                                    { DIG 2 ; UNIT ; TRANSFER_TOKENS } ;
+                                  DUP 3 ;
+                                  DUP 4 ;
+                                  CDR ;
+                                  DUP ;
+                                  CDR ;
+                                  DIG 5 ;
+                                  CDR ;
+                                  CDR ;
+                                  CDR ;
+                                  DUP 6 ;
+                                  CAR ;
+                                  CAR ;
+                                  DUP 2 ;
+                                  CAR ;
+                                  DUP 2 ;
+                                  MEM ;
+                                  IF { DUP 2 ; DIG 2 ; CDR ; DIG 7 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 }
+                                     { DUP 2 ;
+                                       DUP 3 ;
+                                       CAR ;
+                                       DUP 3 ;
+                                       PUSH bool True ;
+                                       SWAP ;
+                                       UPDATE ;
+                                       UPDATE 1 ;
+                                       DIG 2 ;
+                                       CDR ;
+                                       DIG 7 ;
+                                       DIG 3 ;
+                                       SWAP ;
+                                       SOME ;
+                                       SWAP ;
+                                       UPDATE ;
+                                       UPDATE 2 } ;
+                                  UPDATE 2 ;
+                                  UPDATE 2 ;
+                                  UPDATE 2 ;
+                                  NIL operation ;
+                                  DIG 2 ;
+                                  CONS ;
+                                  PAIR } } }
+                       { DUP 2 ;
+                         CAR ;
+                         CDR ;
+                         CDR ;
+                         SENDER ;
+                         COMPARE ;
+                         EQ ;
+                         IF {} { PUSH nat 168 ; FAILWITH } ;
+                         PUSH mutez 1 ;
+                         AMOUNT ;
+                         COMPARE ;
+                         LT ;
+                         IF {} { PUSH nat 118 ; FAILWITH } ;
+                         UNIT ;
+                         LEFT unit ;
+                         LEFT unit ;
+                         IF_LEFT
+                           { IF_LEFT { DROP ; PUSH nat 1 } { DROP ; PUSH nat 0 } }
+                           { DROP ; PUSH nat 2 } ;
+                         DUP 2 ;
+                         CDR ;
+                         CAR ;
+                         IF_LEFT { DROP ; PUSH nat 0 } { DROP ; PUSH nat 1 } ;
+                         NOW ;
+                         DUP 4 ;
+                         CDR ;
+                         CDR ;
+                         DUP 5 ;
+                         CAR ;
+                         CAR ;
+                         DIG 5 ;
+                         CAR ;
+                         CDR ;
+                         PAIR ;
+                         PAIR ;
+                         PAIR 4 ;
+                         DUP 2 ;
+                         CAR ;
+                         CAR ;
+                         CDR ;
+                         DUP 2 ;
+                         CAR ;
+                         CAR ;
+                         CAR ;
+                         GET 5 ;
+                         IF_NONE
+                           { DROP 2 ; PUSH nat 109 ; FAILWITH }
+                           { DUP 3 ;
+                             CAR ;
+                             CAR ;
+                             CAR ;
+                             GET 8 ;
+                             IF_NONE
+                               { PUSH bool False }
+                               { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ;
+                             IF { DUP ;
+                                  CONTRACT %approve (pair (address %spender) (nat %value)) ;
+                                  IF_NONE { PUSH nat 157 ; FAILWITH } {} ;
+                                  PUSH mutez 0 ;
+                                  DUP 5 ;
+                                  CAR ;
+                                  CAR ;
+                                  CDR ;
+                                  DUP 5 ;
+                                  PAIR ;
+                                  TRANSFER_TOKENS }
+                                { DUP 3 ;
+                                  CAR ;
+                                  CAR ;
+                                  CAR ;
+                                  GET 8 ;
+                                  IF_NONE
+                                    { PUSH bool False }
+                                    { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ;
+                                  IF { SELF_ADDRESS ;
+                                       DUP 2 ;
+                                       CONTRACT %add_operator
+                                         (pair (pair (address %operator) (address %owner)) (nat %token_id)) ;
+                                       IF_NONE { PUSH nat 157 ; FAILWITH } {} ;
+                                       PUSH mutez 0 ;
+                                       DUP 6 ;
+                                       CAR ;
+                                       CAR ;
+                                       CAR ;
+                                       CAR ;
+                                       DIG 3 ;
+                                       DUP 6 ;
+                                       PAIR ;
+                                       PAIR ;
+                                       TRANSFER_TOKENS }
+                                     { PUSH nat 108 ; FAILWITH } } ;
+                             DUP 3 ;
+                             CONTRACT %deposit
+                               (pair (pair %swap
+                                        (pair %from
+                                           (pair %token
+                                              (nat %token_id)
+                                              (string %name)
+                                              (option %address address)
+                                              (nat %decimals)
+                                              (option %standard string))
+                                           (nat %amount))
+                                        (pair %to
+                                           (nat %token_id)
+                                           (string %name)
+                                           (option %address address)
+                                           (nat %decimals)
+                                           (option %standard string)))
+                                     (timestamp %created_at)
+                                     (nat %side)
+                                     (nat %tolerance)) ;
+                             IF_NONE { PUSH nat 157 ; FAILWITH } {} ;
+                             PUSH mutez 0 ;
+                             DUP 6 ;
+                             TRANSFER_TOKENS ;
+                             DUP 5 ;
+                             CAR ;
+                             CAR ;
+                             CAR ;
+                             GET 8 ;
+                             IF_NONE
+                               { PUSH bool False }
+                               { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ;
+                             IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; NONE operation }
+                                { DUP 5 ;
+                                  CAR ;
+                                  CAR ;
+                                  CAR ;
+                                  GET 8 ;
+                                  IF_NONE
+                                    { PUSH bool False }
+                                    { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ;
+                                  IF { SELF_ADDRESS ;
+                                       DIG 3 ;
+                                       CONTRACT %remove_operator
+                                         (pair (pair (address %operator) (address %owner)) (nat %token_id)) ;
+                                       IF_NONE { PUSH nat 157 ; FAILWITH } {} ;
+                                       PUSH mutez 0 ;
+                                       DIG 6 ;
+                                       CAR ;
+                                       CAR ;
+                                       CAR ;
+                                       CAR ;
+                                       DIG 3 ;
+                                       DIG 6 ;
+                                       PAIR ;
+                                       PAIR ;
+                                       TRANSFER_TOKENS ;
+                                       SOME }
+                                     { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; PUSH nat 108 ; FAILWITH } } ;
+                             IF_NONE { NIL operation } { NIL operation ; SWAP ; CONS } ;
+                             SWAP ;
+                             CONS ;
+                             SWAP ;
+                             CONS } ;
+                         PAIR } } } }
+           { DROP ;
+             PUSH mutez 1 ;
+             AMOUNT ;
+             COMPARE ;
+             LT ;
+             IF {} { PUSH nat 118 ; FAILWITH } ;
+             SENDER ;
+             DUP 2 ;
+             CDR ;
+             CDR ;
+             CDR ;
+             DUP ;
+             CAR ;
+             DUP 3 ;
+             MEM ;
+             IF { CDR ;
+                  DUP 2 ;
+                  GET ;
+                  IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } }
+                { DROP ; NONE (pair (pair address nat) mutez) } ;
+             IF_NONE
+               { DROP 4 ; PUSH nat 151 ; FAILWITH }
+               { UNPAIR ;
+                 CDR ;
+                 DUP 4 ;
+                 CDR ;
+                 CDR ;
+                 CAR ;
+                 INT ;
+                 PUSH int 1 ;
+                 SWAP ;
+                 PAIR ;
+                 DUP 2 ;
+                 INT ;
+                 PUSH int 1 ;
+                 SWAP ;
+                 PAIR ;
+                 DUP 2 ;
+                 CAR ;
+                 DUP 2 ;
+                 CDR ;
+                 MUL ;
+                 DIG 2 ;
+                 CDR ;
+                 DIG 2 ;
+                 CAR ;
+                 MUL ;
+                 PAIR ;
+                 EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ;
+                 DUP 6 ;
+                 CDR ;
+                 CAR ;
+                 CAR ;
+                 DUP 3 ;
+                 PAIR 3 ;
+                 DUP 7 ;
+                 SWAP ;
+                 EXEC ;
+                 UNPAIR ;
+                 SWAP ;
+                 EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ;
+                 DIG 3 ;
+                 PAIR ;
+                 PAIR ;
+                 DUP 6 ;
+                 CAR ;
+                 CDR ;
+                 CAR ;
+                 ITER { CDR ;
+                        SWAP ;
+                        UNPAIR ;
+                        UNPAIR ;
+                        DIG 2 ;
+                        DIG 3 ;
+                        DUP 3 ;
+                        PAIR 3 ;
+                        DUP 9 ;
+                        SWAP ;
+                        EXEC ;
+                        UNPAIR ;
+                        DIG 3 ;
+                        SWAP ;
+                        PAIR ;
+                        DUP 10 ;
+                        SWAP ;
+                        EXEC ;
+                        DIG 2 ;
+                        PAIR ;
+                        PAIR } ;
+                 DIG 6 ;
+                 DIG 7 ;
+                 DROP 2 ;
+                 UNPAIR ;
+                 CDR ;
+                 DUP 7 ;
+                 CDR ;
+                 CDR ;
+                 CAR ;
+                 DUP 5 ;
+                 COMPARE ;
+                 GT ;
+                 IF { SWAP ; DIG 2 ; DIG 3 ; DIG 6 ; DROP 5 ; PUSH nat 154 ; FAILWITH }
+                    { DIG 3 ;
+                      DUP 7 ;
+                      CDR ;
+                      CDR ;
+                      CAR ;
+                      SUB ;
+                      ABS ;
+                      DIG 2 ;
+                      DUP 7 ;
+                      DIG 7 ;
+                      CDR ;
+                      DUP ;
+                      CAR ;
+                      DIG 6 ;
+                      UPDATE 1 ;
+                      UPDATE 1 ;
+                      UPDATE 2 ;
+                      DUP ;
+                      CAR ;
+                      DUP ;
+                      CDR ;
+                      DIG 5 ;
+                      UPDATE 1 ;
+                      UPDATE 2 ;
+                      UPDATE 1 ;
+                      DUP ;
+                      CDR ;
+                      DUP ;
+                      CDR ;
+                      DIG 4 ;
+                      UPDATE 1 ;
+                      UPDATE 2 ;
+                      UPDATE 2 ;
+                      PAIR } ;
+                 UNPAIR ;
+                 DUP 4 ;
+                 CONTRACT unit ;
+                 IF_NONE { PUSH nat 102 ; FAILWITH } { DUP 4 ; UNIT ; TRANSFER_TOKENS } ;
+                 SELF_ADDRESS ;
+                 NIL operation ;
+                 DIG 4 ;
+                 ITER { CDR ;
+                        DUP ;
+                        CAR ;
+                        GET 5 ;
+                        IF_NONE
+                          { DROP ; PUSH nat 109 ; FAILWITH }
+                          { DUP 2 ;
+                            CAR ;
+                            GET 8 ;
+                            IF_NONE
+                              { DROP 2 ; PUSH nat 108 ; FAILWITH }
+                              { PUSH string "FA1.2 token" ;
+                                DUP 2 ;
+                                COMPARE ;
+                                EQ ;
+                                IF { DROP ;
+                                     CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ;
+                                     IF_NONE { PUSH nat 101 ; FAILWITH } {} ;
+                                     PUSH mutez 0 ;
+                                     DIG 2 ;
+                                     CDR ;
+                                     DUP 9 ;
+                                     DUP 6 ;
+                                     PAIR 3 ;
+                                     TRANSFER_TOKENS }
+                                   { PUSH string "FA2 token" ;
+                                     SWAP ;
+                                     COMPARE ;
+                                     EQ ;
+                                     IF { CONTRACT %transfer
+                                            (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ;
+                                          IF_NONE { PUSH nat 101 ; FAILWITH } {} ;
+                                          PUSH mutez 0 ;
+                                          NIL (pair address (list (pair address nat nat))) ;
+                                          NIL (pair address nat nat) ;
+                                          DUP 5 ;
+                                          CDR ;
+                                          DIG 5 ;
+                                          CAR ;
+                                          CAR ;
+                                          DUP 12 ;
+                                          PAIR 3 ;
+                                          CONS ;
+                                          DUP 6 ;
+                                          PAIR ;
+                                          CONS ;
+                                          TRANSFER_TOKENS }
+                                        { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ;
+                        CONS } ;
+                 SWAP ;
+                 DROP ;
+                 DUP 3 ;
+                 DUP 4 ;
+                 CDR ;
+                 DUP ;
+                 CDR ;
+                 DIG 5 ;
+                 CDR ;
+                 CDR ;
+                 CDR ;
+                 DUP ;
+                 CAR ;
+                 DUP 9 ;
+                 MEM ;
+                 IF { DUP ;
+                      CDR ;
+                      DIG 8 ;
+                      NONE (pair (pair address nat) mutez) ;
+                      SWAP ;
+                      UPDATE ;
+                      UPDATE 2 }
+                    { DIG 7 ; DROP } ;
+                 UPDATE 2 ;
+                 UPDATE 2 ;
+                 UPDATE 2 ;
+                 PUSH mutez 0 ;
+                 DIG 4 ;
+                 COMPARE ;
+                 GT ;
+                 IF { SWAP ; DIG 2 ; CONS } { DIG 2 ; DROP ; SWAP } ;
+                 PAIR } } } ;
+  view "get_native_token_of_vault"
+       unit
+       (pair (nat %token_id)
+             (string %name)
+             (option %address address)
+             (nat %decimals)
+             (option %standard string))
+       { CDR ; CDR ; CAR ; CAR ; CAR } ;
+  view "get_vault_balances"
+       unit
+       (pair (pair (pair %token
+                      (nat %token_id)
+                      (string %name)
+                      (option %address address)
+                      (nat %decimals)
+                      (option %standard string))
+                   (nat %amount))
+             (map string
+                  (pair (pair %token
+                           (nat %token_id)
+                           (string %name)
+                           (option %address address)
+                           (nat %decimals)
+                           (option %standard string))
+                        (nat %amount))))
+       { CDR ; DUP ; CAR ; CDR ; CAR ; SWAP ; CDR ; CAR ; CAR ; PAIR } }
+
diff --git a/batcher/michelson/tzbtc-vault-storage-ghostnet.tz b/batcher/michelson/tzbtc-vault-storage-ghostnet.tz
new file mode 100644
index 00000000..0ae4c4da
--- /dev/null
+++ b/batcher/michelson/tzbtc-vault-storage-ghostnet.tz
@@ -0,0 +1,10 @@
+(Pair (Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL")
+            {}
+            "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL")
+      (Pair (Pair (Pair 0 "tzBTC" (Some "KT1P8RdJ5MfHMK5phKJ5JsfNfask5v2b2NQS") 8 (Some "FA1.2 token"))
+                  0)
+            "KT1SG9z3pU1cNh8dSranm5C5HXWphWi2pLwx")
+      0
+      {}
+      {})
+
diff --git a/batcher/storage/tzbtc_vault_storage_ghostnet.mligo b/batcher/storage/tzbtc_vault_storage_ghostnet.mligo
index 6f6489ab..e766fc0b 100644
--- a/batcher/storage/tzbtc_vault_storage_ghostnet.mligo
+++ b/batcher/storage/tzbtc_vault_storage_ghostnet.mligo
@@ -2,7 +2,7 @@
 #import "../types.mligo" "Types"
 let f(_:unit) : Vault.Vault.storage = {
   administrator = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address);
-  batcher = ("" : address);
+  batcher = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address);
   marketmaker = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address);
   tokenmanager = ("KT1SG9z3pU1cNh8dSranm5C5HXWphWi2pLwx" : address);
   total_shares = 0n;