diff --git a/.gitattributes b/.gitattributes
index 3ff2dd9..c80223e 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,2 @@
-tests/* linguist-vendored
+unit-tests/* linguist-vendored
+* text=lf
\ No newline at end of file
diff --git a/Clarinet.toml b/Clarinet.toml
index 0dc7b08..af380ed 100644
--- a/Clarinet.toml
+++ b/Clarinet.toml
@@ -4,7 +4,20 @@ description = ''
 authors = []
 telemetry = false
 cache_dir = './.cache'
-requirements = []
+
+[[project.requirements]]
+contract_id = 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2'
+
+[[project.requirements]]
+contract_id = 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-ecc-v1'
+
+[[project.requirements]]
+contract_id = 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-merkle-tree-keccak160-v1'
+
+[contracts.pyth-helper-v1]
+path = 'contracts/pyth-helper-v1.clar'
+clarity_version = 2
+epoch = 2.4
 
 [contracts.pyth-governance-v1]
 path = 'contracts/pyth-governance-v1.clar'
@@ -21,7 +34,6 @@ path = 'contracts/pyth-store-v1.clar'
 clarity_version = 2
 epoch = 2.4
 
-
 [contracts.pyth-pnau-decoder-v1]
 path = 'contracts/pyth-pnau-decoder-v1.clar'
 clarity_version = 2
@@ -42,17 +54,6 @@ path = 'contracts/wormhole/wormhole-traits-v1.clar'
 clarity_version = 2
 epoch = 2.4
 
-[contracts.hk-cursor-v1]
-path = 'contracts/hiro-kit/hk-cursor-v1.clar'
-clarity_version = 2
-epoch = 2.4
-
-[contracts.hk-merkle-tree-keccak160-v1]
-path = 'contracts/hiro-kit/hk-merkle-tree-keccak160-v1.clar'
-clarity_version = 2
-epoch = 2.4
-
-
 [repl.analysis]
 passes = ['check_checker']
 
diff --git a/contracts/hiro-kit/hk-cursor-v1.clar b/contracts/hiro-kit/hk-cursor-v1.clar
deleted file mode 100644
index 32cdf77..0000000
--- a/contracts/hiro-kit/hk-cursor-v1.clar
+++ /dev/null
@@ -1,133 +0,0 @@
-;; Title: hiro-kit-cursor
-;; Version: v1
-
-(define-read-only (read-buff-1 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u1)) (err u1)) u1) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u1) }
-    }))
-
-(define-read-only (read-buff-2 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u2)) (err u1)) u2) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u2) }
-    }))
-
-(define-read-only (read-buff-4 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u4)) (err u1)) u4) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u4) }
-    }))
-
-(define-read-only (read-buff-8 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u8)) (err u1)) u8) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u8) }
-    }))
-
-(define-read-only (read-buff-16 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u16)) (err u1)) u16) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u16) }
-    }))
-
-(define-read-only (read-buff-20 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u20)) (err u1)) u20) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u20) }
-    }))
-
-(define-read-only (read-buff-32 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u32)) (err u1)) u32) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u32) }
-    }))
-
-(define-read-only (read-buff-64 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u64)) (err u1)) u64) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u64) }
-    }))
-
-(define-read-only (read-buff-65 (cursor { bytes: (buff 8192), pos: uint }))
-    (ok { 
-        value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) (get pos cursor) (+ (get pos cursor) u65)) (err u1)) u65) (err u1)), 
-        next: { bytes: (get bytes cursor), pos: (+ (get pos cursor) u65) }
-    }))
-
-(define-read-only (read-buff-8192-max (cursor { bytes: (buff 8192), pos: uint }) (size (optional uint)))
-    (let ((min (get pos cursor))
-          (max (match size value 
-            (+ value (get pos cursor))
-            (len (get bytes cursor)))))
-      (ok { 
-          value: (unwrap! (as-max-len? (unwrap! (slice? (get bytes cursor) min max) (err u1)) u8192) (err u1)), 
-          next: { bytes: (get bytes cursor), pos: max }
-      })))
-
-(define-read-only (read-uint-8 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-1 cursor))))
-        (ok (merge cursor-bytes { value: (buff-to-uint-be (get value cursor-bytes)) }))))
-
-(define-read-only (read-uint-16 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-2 cursor))))
-        (ok (merge cursor-bytes { value: (buff-to-uint-be (get value cursor-bytes)) }))))
-
-(define-read-only (read-uint-32 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-4 cursor))))
-        (ok (merge cursor-bytes { value: (buff-to-uint-be (get value cursor-bytes)) }))))
-
-(define-read-only (read-uint-64 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-8 cursor))))
-        (ok (merge cursor-bytes { value: (buff-to-uint-be (get value cursor-bytes)) }))))
-
-(define-read-only (read-uint-128 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-16 cursor))))
-        (ok (merge cursor-bytes { value: (buff-to-uint-be (get value cursor-bytes)) }))))
-
-(define-read-only (read-int-8 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-1 cursor))))
-        (ok (merge 
-            cursor-bytes 
-            { value: (bit-shift-right (bit-shift-left (buff-to-int-be (get value cursor-bytes)) u120) u120) }))))
-
-(define-read-only (read-int-16 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-2 cursor))))
-        (ok (merge 
-            cursor-bytes 
-            { value: (bit-shift-right (bit-shift-left (buff-to-int-be (get value cursor-bytes)) u112) u112) }))))
-
-(define-read-only (read-int-32 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-4 cursor))))
-        (ok (merge 
-            cursor-bytes 
-            { value: (bit-shift-right (bit-shift-left (buff-to-int-be (get value cursor-bytes)) u96) u96) }))))
-
-(define-read-only (read-int-64 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-8 cursor))))
-        (ok (merge 
-            cursor-bytes 
-            { value: (bit-shift-right (bit-shift-left (buff-to-int-be (get value cursor-bytes)) u64) u64) }))))
-
-(define-read-only (read-int-128 (cursor { bytes: (buff 8192), pos: uint }))
-    (let ((cursor-bytes (try! (read-buff-16 cursor))))
-        (ok (merge 
-            cursor-bytes 
-            { value: (buff-to-int-be (get value cursor-bytes)) }))))
-
-(define-read-only (new (bytes (buff 8192)) (offset (optional uint)))
-    { 
-        value: none, 
-        next: { bytes: bytes, pos: (match offset value value u0) }
-    })
-
-(define-read-only (advance (cursor { bytes: (buff 8192), pos: uint }) (offset uint))
-     { bytes: (get bytes cursor), pos: (+ (get pos cursor) offset) })
-
-(define-read-only (slice (cursor { bytes: (buff 8192), pos: uint }) (size (optional uint)))
-    (match (slice? (get bytes cursor) 
-                   (get pos cursor) 
-                   (match size value 
-                   (+ (get pos cursor) value)    
-                      (len (get bytes cursor))))
-        bytes bytes 0x))
diff --git a/contracts/hiro-kit/hk-merkle-tree-keccak160-v1.clar b/contracts/hiro-kit/hk-merkle-tree-keccak160-v1.clar
deleted file mode 100644
index 68bb25b..0000000
--- a/contracts/hiro-kit/hk-merkle-tree-keccak160-v1.clar
+++ /dev/null
@@ -1,27 +0,0 @@
-;; Title: hiro-merkle-tree-keccak160
-;; Version: v1
-
-(define-read-only (keccak160 (bytes (buff 1024)))
-    (unwrap-panic (as-max-len? (unwrap-panic (slice? (keccak256 bytes) u0 u20)) u20)))
-
-(define-read-only (buff-20-to-uint (bytes (buff 20)))
-    (buff-to-uint-be (unwrap-panic (as-max-len? (unwrap-panic (slice? bytes u0 u15)) u16))))
-
-(define-read-only (hash-leaf (bytes (buff 255)))
-    (keccak160 (concat 0x00 bytes)))
-
-(define-read-only (hash-nodes (node-1 (buff 20)) (node-2 (buff 20)))
-    (let ((uint-1 (buff-20-to-uint node-1))
-          (uint-2 (buff-20-to-uint node-2))
-          (sequence (if (< uint-2 uint-1) 
-            (concat (concat 0x01 node-2) node-1)
-            (concat (concat 0x01 node-1) node-2))))
-    (keccak160 sequence)))
-
-(define-read-only (check-proof (root-hash (buff 20)) (leaf (buff 255)) (path (list 255 (buff 20))))
-    (let ((hashed-leaf (hash-leaf leaf))
-          (computed-root-hash (fold hash-path path hashed-leaf)))
-        (is-eq root-hash computed-root-hash)))
-
-(define-private (hash-path (entry (buff 20)) (acc (buff 20)))
-    (hash-nodes entry acc))
diff --git a/contracts/pyth-governance-v1.clar b/contracts/pyth-governance-v1.clar
index 6190ab6..38f8390 100644
--- a/contracts/pyth-governance-v1.clar
+++ b/contracts/pyth-governance-v1.clar
@@ -12,22 +12,40 @@
 
 ;; VAA including some commands for administrating Pyth contract
 ;; The oracle contract address must be upgraded
-(define-constant PTGM_UPGRADE_CONTRACT_PYTH_ORACLE 0x00)
+(define-constant PTGM_UPDATE_PYTH_ORACLE_ADDRESS 0x00)
 ;; Authorize governance change
-(define-constant PTGM_AUTHORIZE_GOVERNANCE_DATA_SOURCE_TRANSFER 0x01)
+(define-constant PTGM_UPDATE_GOVERNANCE_DATA_SOURCE 0x01)
 ;; Which wormhole emitter is allowed to send price updates
-(define-constant PTGM_SET_DATA_SOURCES 0x02)
+(define-constant PTGM_UPDATE_PRICES_DATA_SOURCES 0x02)
 ;; Fee is charged when you submit a new price
-(define-constant PTGM_SET_FEE 0x03)
-;; Emit a request for governance change 
-(define-constant PTGM_REQUEST_GOVERNANCE_DATA_SOURCE_TRANSFER 0x05)
-;; Wormhole contract 
-(define-constant PTGM_UPGRADE_CONTRACT_WORMHOLE_CORE 0x06)
-;; Fee is charged when you submit a new price
-(define-constant PTGM_SET_RECIPIENT_ADDRESS 0xa0)
-;; Error unauthorized control flow
-(define-constant ERR_UNAUTHORIZED_ACCESS (err u404))
+(define-constant PTGM_UPDATE_FEE 0x03)
+;; Upgrade wormhole contract 
+(define-constant PTGM_UPDATE_WORMHOLE_CORE_ADDRESS 0x06)
+;; Special Stacks operation: update recipient address
+(define-constant PTGM_UPDATE_RECIPIENT_ADDRESS 0xa0)
+;; Special Stacks operation: update storage contract address
+(define-constant PTGM_UPDATE_PYTH_STORE_ADDRESS 0xa1)
+;; Special Stacks operation: update decoder contract address
+(define-constant PTGM_UPDATE_PYTH_DECODER_ADDRESS 0xa2)
+;; TODO: Pyth team to assign a chain id to Stacks.
+(define-constant EXPECTED_CHAIN_ID 0x00)
+;; TODO: Pyth team to assign a module to Stacks.
+(define-constant EXPECTED_MODULE 0x00)
 
+;; Error unauthorized control flow
+(define-constant ERR_UNAUTHORIZED_ACCESS (err u4004))
+;; Error unexpected action
+(define-constant ERR_UNEXPECTED_ACTION (err u4001))
+;; Error unexpected action payload
+(define-constant ERR_UNEXPECTED_ACTION_PAYLOAD (err u4002))
+;; Error unexpected action
+(define-constant ERR_INVALID_ACTION_PAYLOAD (err u4003))
+;; Error outdated action
+(define-constant ERR_OUTDATED (err u4005))
+;; Error unauthorized update
+(define-constant ERR_UNAUTHORIZED_UPDATE (err u4006))
+;; Error parsing PGTM
+(define-constant ERR_INVALID_PTGM (err u4007))
 
 (define-data-var fee-value 
   { mantissa: uint, exponent: uint } 
@@ -35,12 +53,12 @@
 (define-data-var price-data-sources (buff 32) 0x)
 (define-data-var governance-data-source 
   { emitter-chain: uint, emitter-address: (buff 32) }
-  { emitter-chain: u0, emitter-address: 0x })
+  { emitter-chain: u0, emitter-address: 0x0000000000000000000000000000000000000000000000000000000000000000 }) ;; TODO: set initial value
 (define-data-var fee-recipient-address principal tx-sender)
 
-(define-map prices-data-sources uint 
-  (list 255 { emitter-chain: uint, emitter-address: (buff 32) }))
-(define-data-var current-prices-data-sources-id uint u0)
+(define-data-var last-sequence-processed uint u0) ;; TODO: set initial value
+
+(define-data-var prices-data-sources (list 255 { emitter-chain: uint, emitter-address: (buff 32) }) (list))
 
 (define-map execution-plans uint { 
   pyth-oracle-contract: principal,
@@ -75,11 +93,7 @@
           ;; Other contract
           (if (is-eq contract-caller (get pyth-decoder-contract expected-execution-plan))
             ;; The decoding contract is checking its execution flow
-            (let ((execution-plan (unwrap! execution-plan-opt ERR_UNAUTHORIZED_ACCESS)))
-              ;; Must always be invoked by the proxy
-              (try! (expect-contract-call-performed-by-expected-oracle-contract former-contract-caller expected-execution-plan))
-              ;; Ensure that wormhole contract is the one expected
-              (try! (expect-active-wormhole-contract (get wormhole-core-contract execution-plan) expected-execution-plan)))
+            (try! (expect-contract-call-performed-by-expected-oracle-contract former-contract-caller expected-execution-plan))
             (if (is-eq contract-caller (get pyth-oracle-contract expected-execution-plan))
               ;; The proxy contract is checking its execution flow
               (let ((execution-plan (unwrap! execution-plan-opt ERR_UNAUTHORIZED_ACCESS)))
@@ -98,6 +112,152 @@
       ;; Ensure that storage contract is the one expected
       (expect-active-storage-contract storage-contract expected-execution-plan)))
 
+(define-read-only (get-current-execution-plan)
+  (unwrap-panic (map-get? execution-plans (var-get current-execution-plan-id))))
+
+(define-read-only (get-fee-info)
+  (merge (var-get fee-value) { address: (var-get fee-recipient-address) }))
+
+(define-read-only (get-authorized-prices-data-sources)
+  (var-get prices-data-sources))
+
+(define-public (update-fee-value (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_FEE) ERR_UNEXPECTED_ACTION)
+    ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update fee-value
+    (let ((updated-data (try! (parse-and-verify-fee-value (get body ptgm)))))
+      (var-set fee-value updated-data)
+      (ok updated-data))))
+
+(define-public (update-fee-recipient-address (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_RECIPIENT_ADDRESS) ERR_UNEXPECTED_ACTION)
+      ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update fee-recipient address
+    (let ((updated-data (unwrap! (from-consensus-buff? principal (get body ptgm)) ERR_UNEXPECTED_ACTION_PAYLOAD)))
+      (var-set fee-recipient-address updated-data)
+      (ok updated-data))))
+
+(define-public (update-wormhole-core-contract (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (next-execution-plan-id (+ (var-get current-execution-plan-id) u1))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_WORMHOLE_CORE_ADDRESS) ERR_UNEXPECTED_ACTION)
+    ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update execution plan
+    (let ((updated-data (unwrap! (from-consensus-buff? principal (get body ptgm)) ERR_UNEXPECTED_ACTION_PAYLOAD)))
+      (map-set execution-plans next-execution-plan-id (merge expected-execution-plan { wormhole-core-contract: updated-data }))
+      (var-set current-execution-plan-id next-execution-plan-id)
+      (ok (get-current-execution-plan)))))
+
+(define-public (update-pyth-oracle-contract (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (next-execution-plan-id (+ (var-get current-execution-plan-id) u1))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_PYTH_ORACLE_ADDRESS) ERR_UNEXPECTED_ACTION)
+    ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update execution plan
+    (let ((updated-data (unwrap! (from-consensus-buff? principal (get body ptgm)) ERR_UNEXPECTED_ACTION_PAYLOAD)))
+      (map-set execution-plans next-execution-plan-id (merge expected-execution-plan { pyth-oracle-contract: updated-data }))
+      (var-set current-execution-plan-id next-execution-plan-id)
+      (ok (get-current-execution-plan)))))
+
+(define-public (update-pyth-decoder-contract (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (next-execution-plan-id (+ (var-get current-execution-plan-id) u1))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_PYTH_DECODER_ADDRESS) ERR_UNEXPECTED_ACTION)
+    ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update execution plan
+    (let ((updated-data (unwrap! (from-consensus-buff? principal (get body ptgm)) ERR_UNEXPECTED_ACTION_PAYLOAD)))
+      (map-set execution-plans next-execution-plan-id (merge expected-execution-plan { pyth-decoder-contract: updated-data }))
+      (var-set current-execution-plan-id next-execution-plan-id)
+      (ok (get-current-execution-plan)))))
+
+(define-public (update-pyth-store-contract (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (next-execution-plan-id (+ (var-get current-execution-plan-id) u1))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_PYTH_STORE_ADDRESS) ERR_UNEXPECTED_ACTION)
+    ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update execution plan
+    (let ((updated-data (unwrap! (from-consensus-buff? principal (get body ptgm)) ERR_UNEXPECTED_ACTION_PAYLOAD)))
+      (map-set execution-plans next-execution-plan-id (merge expected-execution-plan { pyth-storage-contract: updated-data }))
+      (var-set current-execution-plan-id next-execution-plan-id)
+      (ok (get-current-execution-plan)))))
+
+(define-public (update-prices-data-sources (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_PRICES_DATA_SOURCES) ERR_UNEXPECTED_ACTION)
+    ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update prices-data-sources
+    (let ((updated-data (try! (parse-and-verify-prices-data-sources (get body ptgm)))))
+      (var-set prices-data-sources updated-data)
+      (ok updated-data))))
+
+(define-public (update-governance-data-source (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
+  (let ((expected-execution-plan (get-current-execution-plan))
+        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
+        (ptgm (try! (parse-and-verify-ptgm (get payload vaa) (get sequence vaa)))))
+    ;; Ensure action's expectation
+    (asserts! (is-eq (get action ptgm) PTGM_UPDATE_GOVERNANCE_DATA_SOURCE) ERR_UNEXPECTED_ACTION)
+    ;; Ensure that the action is authorized
+    (try! (check-update-source (get emitter-chain vaa) (get emitter-address vaa)))
+    ;; Ensure that the lastest wormhole contract is used
+    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
+    ;; Update prices-data-sources
+    (let ((updated-data (try! (parse-and-verify-governance-data-source (get body ptgm)))))
+      (var-set governance-data-source updated-data)
+      (ok updated-data))))
+
+(define-private (check-update-source (emitter-chain uint) (emitter-address (buff 32)))
+  (let ((authorized-data-source (var-get governance-data-source)))
+    ;; Check data-source
+    (asserts! (is-eq 
+        authorized-data-source 
+        { emitter-chain: emitter-chain, emitter-address: emitter-address })
+      ERR_UNAUTHORIZED_UPDATE)
+    (ok true)))
+
 (define-private (expect-contract-call-performed-by-expected-oracle-contract 
   (former-contract-caller principal) 
   (expected-plan { 
@@ -124,7 +284,8 @@
     (asserts! 
       (is-eq 
         (contract-of storage-contract) 
-        (get pyth-storage-contract expected-plan)) ERR_UNAUTHORIZED_ACCESS)
+        (get pyth-storage-contract expected-plan)) 
+      ERR_UNAUTHORIZED_ACCESS)
     (ok true)))
 
 (define-private (expect-active-decoder-contract 
@@ -139,7 +300,8 @@
     (asserts! 
       (is-eq 
         (contract-of decoder-contract) 
-        (get pyth-decoder-contract expected-plan)) ERR_UNAUTHORIZED_ACCESS)
+        (get pyth-decoder-contract expected-plan)) 
+      ERR_UNAUTHORIZED_ACCESS)
     (ok true)))
 
 (define-private (expect-active-wormhole-contract 
@@ -154,132 +316,78 @@
     (asserts! 
       (is-eq 
         (contract-of wormhole-contract) 
-        (get wormhole-core-contract expected-plan)) ERR_UNAUTHORIZED_ACCESS)
+        (get wormhole-core-contract expected-plan))
+      ERR_UNAUTHORIZED_ACCESS)
     (ok true)))
 
-(define-read-only (get-current-execution-plan)
-  (unwrap-panic (map-get? execution-plans (var-get current-execution-plan-id))))
-
-(define-read-only (get-fee-info)
-  (merge (var-get fee-value) { address: (var-get fee-recipient-address) }))
+(define-private (parse-and-verify-ptgm (ptgm-bytes (buff 8192)) (sequence uint))
+  (let ((cursor-magic (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-4 { bytes: ptgm-bytes, pos: u0 }) 
+          ERR_INVALID_PTGM))
+        (cursor-module (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-1 (get next cursor-magic)) 
+          ERR_INVALID_PTGM))
+        (cursor-action (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-1 (get next cursor-module)) 
+          ERR_INVALID_PTGM))
+        (cursor-target-chain-id (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-1 (get next cursor-action)) 
+          ERR_INVALID_PTGM))
+        (cursor-body (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-8192-max (get next cursor-target-chain-id) none)
+          ERR_INVALID_PTGM)))
+    ;; Check magic bytes
+    (asserts! (is-eq (get value cursor-magic) PTGM_MAGIC) ERR_INVALID_PTGM)
+    ;; Check target-chain-id
+    (asserts! (is-eq (get value cursor-target-chain-id) EXPECTED_CHAIN_ID) ERR_INVALID_PTGM)
+    ;; Check module
+    (asserts! (is-eq (get value cursor-module) EXPECTED_MODULE) ERR_INVALID_PTGM)
+    ;; Check Sequence
+    (asserts! (> sequence (var-get last-sequence-processed)) ERR_OUTDATED)
+    ;; Update Sequence
+    (var-set last-sequence-processed sequence)
+    (ok { 
+      action: (get value cursor-action), 
+      target-chain-id: (get value cursor-target-chain-id), 
+      module: (get value cursor-module),
+      cursor: cursor-target-chain-id,
+      body: (get value cursor-body)
+    })))
 
-(define-public (update-fee-value (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
-  (let ((expected-execution-plan (get-current-execution-plan))
-        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
-        (fee-value-update (try! (parse-and-verify-fee-value (get payload vaa)))))
-    ;; Ensure that the lastest wormhole contract is used
-    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
-    ;; 
-    (var-set fee-value fee-value-update)
-    (ok fee-value-update)))
+(define-private (parse-and-verify-fee-value (ptgm-body (buff 8192)))
+  (let ((cursor-ptgm-body (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 new ptgm-body none))
+        (cursor-mantissa (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-ptgm-body)) 
+          ERR_INVALID_ACTION_PAYLOAD))
+        (cursor-exponent (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-mantissa)) 
+          ERR_INVALID_ACTION_PAYLOAD)))
+    (ok { 
+      mantissa: (get value cursor-mantissa), 
+      exponent: (get value cursor-exponent) 
+    })))
 
-(define-public (update-fee-recipient-address (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
-  (let ((expected-execution-plan (get-current-execution-plan))
-        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
-        (ptgm (try! (parse-and-verify-ptgm (get payload vaa)))))
-    ;; Ensure that the lastest wormhole contract is used
-    (asserts! (is-eq (get action ptgm) PTGM_SET_RECIPIENT_ADDRESS) (err u1))
-    ;; Ensure that the lastest wormhole contract is used
-    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
-    ;;
-    (let ((updated-address (unwrap! (from-consensus-buff? principal (get body ptgm)) (err u2))))
-      (var-set fee-recipient-address updated-address)
-      (ok updated-address))))
+(define-private (parse-and-verify-governance-data-source (ptgm-body (buff 8192)))
+  (let ((cursor-ptgm-body (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 new ptgm-body none))
+        (cursor-emitter-chain (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-16 (get next cursor-ptgm-body))
+          ERR_INVALID_ACTION_PAYLOAD))
+        (cursor-emitter-address (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-32 (get next cursor-emitter-chain))
+          ERR_INVALID_ACTION_PAYLOAD)))
+    (ok { 
+      emitter-chain: (get value cursor-emitter-chain), 
+      emitter-address: (get value cursor-emitter-address) 
+    })))
 
-(define-public (update-wormhole-core-contract (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
-  (let ((expected-execution-plan (get-current-execution-plan))
-        (next-execution-plan-id (+ (var-get current-execution-plan-id) u1))
-        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
-        (ptgm (try! (parse-and-verify-ptgm (get payload vaa)))))
-    ;; Ensure that the lastest wormhole contract is used
-    (asserts! (is-eq (get action ptgm) PTGM_UPGRADE_CONTRACT_WORMHOLE_CORE) (err u1))
-    ;; Ensure that the lastest wormhole contract is used
-    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
-    ;;
-    (let ((updated-address (unwrap! (from-consensus-buff? principal (get body ptgm)) (err u2))))
-      (map-set execution-plans next-execution-plan-id (merge expected-execution-plan { wormhole-core-contract: updated-address }))
-      (var-set current-execution-plan-id next-execution-plan-id)
-      (ok (get-current-execution-plan)))))
 
-(define-public (update-pyth-oracle-contract (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
-  (let ((expected-execution-plan (get-current-execution-plan))
-        (next-execution-plan-id (+ (var-get current-execution-plan-id) u1))
-        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
-        (ptgm (try! (parse-and-verify-ptgm (get payload vaa)))))
-    ;; Ensure that the lastest wormhole contract is used
-    (asserts! (is-eq (get action ptgm) PTGM_UPGRADE_CONTRACT_PYTH_ORACLE) (err u1))
-    ;; Ensure that the lastest wormhole contract is used
-    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
-    ;;
-    (let ((updated-address (unwrap! (from-consensus-buff? principal (get body ptgm)) (err u2))))
-      (map-set execution-plans next-execution-plan-id (merge expected-execution-plan { pyth-oracle-contract: updated-address }))
-      (var-set current-execution-plan-id next-execution-plan-id)
-      (ok (get-current-execution-plan)))))
+(define-private (parse-and-verify-prices-data-sources (pgtm-body (buff 8192)))
+  (let ((cursor-pgtm-body (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 new pgtm-body none))
+        (cursor-num-data-sources (try! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-pgtm-body))))
+        (cursor-data-sources-bytes (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 slice (get next cursor-num-data-sources) none))
+        (data-sources (get result (fold parse-data-source cursor-data-sources-bytes { 
+          result: (list), 
+          cursor: {
+            index: u0,
+            next-update-index: u0
+          },
+          bytes: cursor-data-sources-bytes,
+          limit: (get value cursor-num-data-sources) 
+        }))))
+    (ok data-sources)))
 
-(define-public (update-prices-data-sources (vaa-bytes (buff 8192)) (wormhole-core-contract <wormhole-core-trait>))
-  (let ((expected-execution-plan (get-current-execution-plan))
-        (next-prices-data-sources-id (+ (var-get current-prices-data-sources-id) u1))
-        (vaa (try! (contract-call? wormhole-core-contract parse-and-verify-vaa vaa-bytes)))
-        (prices-data-sources-update (try! (parse-and-verify-prices-data-sources (get payload vaa)))))
-    ;; Ensure that the lastest wormhole contract is used
-    (try! (expect-active-wormhole-contract wormhole-core-contract expected-execution-plan))
-    ;; 
-    (map-set prices-data-sources next-prices-data-sources-id prices-data-sources-update)
-    (ok prices-data-sources-update)))
-
-(define-private (parse-and-verify-ptgm (ptgm-bytes (buff 8192)))
-    (let ((cursor-magic (unwrap! (contract-call? .hk-cursor-v1 read-buff-4 { bytes: ptgm-bytes, pos: u0 }) 
-            (err u0)))
-          (cursor-module (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-magic)) 
-            (err u1)))
-          (cursor-action (unwrap! (contract-call? .hk-cursor-v1 read-buff-1 (get next cursor-module)) 
-            (err u2)))
-          (cursor-target-chain-id (unwrap! (contract-call? .hk-cursor-v1 read-uint-16 (get next cursor-action)) 
-            (err u3)))
-          (cursor-body (unwrap! (contract-call? .hk-cursor-v1 read-buff-8192-max (get next cursor-target-chain-id) none)
-            (err u4))))
-        ;; Check magic bytes
-        (asserts! (is-eq (get value cursor-magic) PTGM_MAGIC) (err u8))
-        ;;
-        (ok { 
-          action: (get value cursor-action), 
-          target-chain-id: (get value cursor-target-chain-id), 
-          module: (get value cursor-module),
-          cursor: cursor-target-chain-id,
-          body: (get value cursor-body)
-        })))
-
-(define-private (parse-and-verify-fee-value (fee-value-bytes (buff 8192)))
-  (let ((ptgm (try! (parse-and-verify-ptgm fee-value-bytes))))
-      (asserts! (is-eq (get action ptgm) PTGM_SET_FEE) (err u9))
-      ;; TODO: Check emitter-chain and emitter-address
-      (let ((cursor-mantissa (unwrap! (contract-call? .hk-cursor-v1 read-uint-64 (get next (get cursor ptgm))) 
-              (err u100)))
-            (cursor-exponent (unwrap! (contract-call? .hk-cursor-v1 read-uint-64 (get next cursor-mantissa)) 
-              (err u100))))
-    (ok { 
-      mantissa: (get value cursor-mantissa), 
-      exponent: (get value cursor-exponent) 
-    }))))
-
-(define-private (parse-and-verify-prices-data-sources (prices-data-sources-bytes (buff 8192)))
-  (let ((ptgm (try! (parse-and-verify-ptgm prices-data-sources-bytes))))
-      (asserts! (is-eq (get action ptgm) PTGM_SET_DATA_SOURCES) (err u1))
-      ;; TODO: Check emitter-chain and emitter-address
-      (let ((cursor-num-data-sources (try! (contract-call? .hk-cursor-v1 read-uint-8 (get next (get cursor ptgm)))))
-            (cursor-data-sources-bytes (contract-call? .hk-cursor-v1 slice (get next cursor-num-data-sources) none))
-            (data-sources (get result (fold parse-data-sources cursor-data-sources-bytes { 
-              result: (list), 
-              cursor: {
-                index: u0,
-                next-update-index: u0
-              },
-              bytes: cursor-data-sources-bytes,
-              limit: (get value cursor-num-data-sources) 
-            }))))
-        (ok data-sources))))
-
-(define-private (parse-data-sources
+(define-private (parse-data-source
       (entry (buff 1)) 
       (acc { 
         cursor: { 
@@ -294,14 +402,14 @@
     acc
     (if (is-eq (get index (get cursor acc)) (get next-update-index (get cursor acc)))
       ;; Parse update
-      (let ((buffer (contract-call? .hk-cursor-v1 new (get bytes acc) (some (get index (get cursor acc)))))
-            (cursor-emitter-chain (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-8 (get next buffer))))
-            (cursor-emitter-address (unwrap-panic (contract-call? .hk-cursor-v1 read-buff-32 (get next cursor-emitter-chain)))))
+      (let ((buffer (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 new (get bytes acc) (some (get index (get cursor acc)))))
+            (cursor-emitter-chain (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-16 (get next buffer))))
+            (cursor-emitter-address (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-32 (get next cursor-emitter-chain)))))
         ;; Perform assertions
         {
           cursor: { 
             index: (+ (get index (get cursor acc)) u1),
-            next-update-index: (+ (get index (get cursor acc)) u33),
+            next-update-index: (+ (get index (get cursor acc)) u34),
           },
           bytes: (get bytes acc),
           result: (unwrap-panic (as-max-len? (append (get result acc) { 
diff --git a/contracts/pyth-p2wh-decoder-v1.clar b/contracts/pyth-p2wh-decoder-v1.clar
index dc3ab3d..6330d2a 100644
--- a/contracts/pyth-p2wh-decoder-v1.clar
+++ b/contracts/pyth-p2wh-decoder-v1.clar
@@ -76,7 +76,7 @@
   (let ((price-feed-entry (unwrap! (map-get? prices { price-feed-id: price-feed-id }) ERR_PF_NOT_FOUND)))
     (ok price-feed-entry)))
     
-(define-read-only (parse-and-verify-price-attestations (pf-bytes (buff 2048)))
+(define-private (parse-and-verify-price-attestations (pf-bytes (buff 2048)))
   (let ((cursor-price-attestations-header (try! (parse-price-attestations-header pf-bytes)))
         (cursor-attestations-count (unwrap! (contract-call? .hk-cursor-v1 read-u16 (get next cursor-price-attestations-header)) 
             ERR_P2WH_PARSING_ATTESTATION_COUNT))
@@ -106,7 +106,7 @@
       price-attestations: price-attestations
     })))
 
-(define-read-only (parse-price-attestations-header (pf-bytes (buff 2048)))
+(define-private (parse-price-attestations-header (pf-bytes (buff 2048)))
   (let ((cursor-magic (unwrap! (contract-call? .hk-cursor-v1 read-buff-4 { bytes: pf-bytes, pos: u0 }) 
           ERR_PF_PARSING_MAGIC_BYTES))
         ;; Todo: check magic bytes
diff --git a/contracts/pyth-pnau-decoder-v1.clar b/contracts/pyth-pnau-decoder-v1.clar
index d5aa3de..6d1a3c8 100644
--- a/contracts/pyth-pnau-decoder-v1.clar
+++ b/contracts/pyth-pnau-decoder-v1.clar
@@ -28,50 +28,61 @@
 (define-constant ERR_VERSION_MIN (err u2003))
 ;; Unable to parse trailing header size
 (define-constant ERR_HEADER_TRAILING_SIZE (err u2004))
-;; Unable to parse update type
+;; Unable to parse proof type
 (define-constant ERR_PROOF_TYPE (err u2005))
+;; Unable to parse update type
+(define-constant ERR_UPDATE_TYPE (err u2006))
+;; Merkle root mismatch
+(define-constant ERR_INVALID_AUWV (err u2007))
 ;; Merkle root mismatch
-(define-constant MERKLE_ROOT_MISMATCH (err u2006))
+(define-constant MERKLE_ROOT_MISMATCH (err u2008))
 ;; Price not found
 (define-constant ERR_NOT_FOUND (err u0))
 ;; Price not found
 (define-constant ERR_UNAUTHORIZED_FLOW (err u2404))
+;; Price update not signed by an authorized source 
+(define-constant ERR_UNAUTHORIZED_PRICE_UPDATE (err u2401))
 
 ;;;; Public functions
 (define-public (decode-and-verify-price-feeds (pnau-bytes (buff 8192)) (wormhole-core-address <wormhole-core-trait>))
   (begin
-    ;; Ensure that updates are always coming from the oracle contract
-    (asserts! (is-eq contract-caller .pyth-oracle-v1) ERR_UNAUTHORIZED_FLOW)
+    ;; Check execution flow
+    (try! (contract-call? .pyth-governance-v1 check-execution-flow contract-caller none))
     ;; Proceed to update
     (let ((prices-updates (try! (decode-pnau-price-update pnau-bytes wormhole-core-address))))
       (ok prices-updates))))
 
 ;;;; Private functions
-;; Note: wormhole-core-address is checked upstream so we will ignore the following warning
 ;; #[filter(pnau-bytes, wormhole-core-address)]
-(define-public (decode-pnau-price-update (pnau-bytes (buff 8192)) (wormhole-core-address <wormhole-core-trait>))
-    (let ((cursor-pnau-header (try! (parse-pnau-header pnau-bytes)))
-          (cursor-pnau-vaa-size (try! (contract-call? .hk-cursor-v1 read-uint-16 (get next cursor-pnau-header))))
-          (cursor-pnau-vaa (try! (contract-call? .hk-cursor-v1 read-buff-8192-max (get next cursor-pnau-vaa-size) (some (get value cursor-pnau-vaa-size)))))
-          (vaa (try! (contract-call? wormhole-core-address parse-and-verify-vaa (get value cursor-pnau-vaa))))
-          (cursor-merkle-root-data (try! (parse-merkle-root-data-from-vaa-payload (get payload vaa))))
-          (decoded-prices-updates (try! (parse-and-verify-prices-updates 
-            (contract-call? .hk-cursor-v1 slice (get next cursor-pnau-vaa) none)
-            (get merkle-root-hash (get value cursor-merkle-root-data)))))
-          (prices-updates (map cast-decoded-price decoded-prices-updates)))
-      (ok prices-updates)))
+(define-private (decode-pnau-price-update (pnau-bytes (buff 8192)) (wormhole-core-address <wormhole-core-trait>))
+  (let ((cursor-pnau-header (try! (parse-pnau-header pnau-bytes)))
+        (cursor-pnau-vaa-size (try! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-16 (get next cursor-pnau-header))))
+        (cursor-pnau-vaa (try! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-8192-max (get next cursor-pnau-vaa-size) (some (get value cursor-pnau-vaa-size)))))
+        (vaa (try! (contract-call? wormhole-core-address parse-and-verify-vaa (get value cursor-pnau-vaa))))
+        (cursor-merkle-root-data (try! (parse-merkle-root-data-from-vaa-payload (get payload vaa))))
+        (decoded-prices-updates (try! (parse-and-verify-prices-updates 
+          (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 slice (get next cursor-pnau-vaa) none)
+          (get merkle-root-hash (get value cursor-merkle-root-data)))))
+        (prices-updates (map cast-decoded-price decoded-prices-updates))
+        (authorized-prices-data-sources (contract-call? .pyth-governance-v1 get-authorized-prices-data-sources)))
+    ;; Ensure that update was published by an data source authorized by governance
+    (unwrap! (index-of? 
+        authorized-prices-data-sources 
+        { emitter-chain: (get emitter-chain vaa), emitter-address: (get emitter-address vaa) }) 
+      ERR_UNAUTHORIZED_PRICE_UPDATE)
+    (ok prices-updates)))
 
 (define-private (parse-merkle-root-data-from-vaa-payload (payload-vaa-bytes (buff 8192)))
-  (let ((cursor-payload-type (unwrap! (contract-call? .hk-cursor-v1 read-buff-4 { bytes: payload-vaa-bytes, pos: u0 }) 
-          (err u0)))
-        (cursor-wh-update-type (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-payload-type)) 
-          (err u0)))
-        (cursor-merkle-root-slot (unwrap! (contract-call? .hk-cursor-v1 read-uint-64 (get next cursor-wh-update-type)) 
-          (err u0)))
-        (cursor-merkle-root-ring-size (unwrap! (contract-call? .hk-cursor-v1 read-uint-32 (get next cursor-merkle-root-slot)) 
-          (err u0)))
-        (cursor-merkle-root-hash (unwrap! (contract-call? .hk-cursor-v1 read-buff-20 (get next cursor-merkle-root-ring-size)) 
-          (err u0))))
+  (let ((cursor-payload-type (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-4 { bytes: payload-vaa-bytes, pos: u0 }) 
+          ERR_INVALID_AUWV))
+        (cursor-wh-update-type (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-payload-type)) 
+          ERR_INVALID_AUWV))
+        (cursor-merkle-root-slot (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-wh-update-type)) 
+          ERR_INVALID_AUWV))
+        (cursor-merkle-root-ring-size (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-32 (get next cursor-merkle-root-slot)) 
+          ERR_INVALID_AUWV))
+        (cursor-merkle-root-hash (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-20 (get next cursor-merkle-root-ring-size)) 
+          ERR_INVALID_AUWV)))
     ;; Check payload type
     (asserts! (is-eq (get value cursor-payload-type) AUWV_MAGIC) ERR_MAGIC_BYTES)
     ;; Check update type
@@ -86,16 +97,16 @@
       next: (get next cursor-merkle-root-hash)
     })))
 
-(define-read-only (parse-pnau-header (pf-bytes (buff 8192)))
-  (let ((cursor-magic (unwrap! (contract-call? .hk-cursor-v1 read-buff-4 { bytes: pf-bytes, pos: u0 }) 
+(define-private (parse-pnau-header (pf-bytes (buff 8192)))
+  (let ((cursor-magic (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-4 { bytes: pf-bytes, pos: u0 }) 
           ERR_MAGIC_BYTES))
-        (cursor-version-maj (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-magic)) 
+        (cursor-version-maj (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-magic)) 
           ERR_VERSION_MAJ))
-        (cursor-version-min (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-version-maj)) 
+        (cursor-version-min (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-version-maj)) 
           ERR_VERSION_MIN))
-        (cursor-header-trailing-size (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-version-min)) 
+        (cursor-header-trailing-size (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-version-min)) 
           ERR_HEADER_TRAILING_SIZE))
-        (cursor-proof-type (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 {
+        (cursor-proof-type (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 {
             bytes: pf-bytes,
             pos: (+ (get pos (get next cursor-header-trailing-size)) (get value cursor-header-trailing-size))})
           ERR_PROOF_TYPE)))
@@ -118,9 +129,9 @@
       next: (get next cursor-proof-type)
     })))
 
-(define-read-only (parse-and-verify-prices-updates (bytes (buff 8192)) (merkle-root-hash (buff 20)))
-  (let ((cursor-num-updates (try! (contract-call? .hk-cursor-v1 read-uint-8 { bytes: bytes, pos: u0 })))
-        (cursor-updates-bytes (contract-call? .hk-cursor-v1 slice (get next cursor-num-updates) none))
+(define-private (parse-and-verify-prices-updates (bytes (buff 8192)) (merkle-root-hash (buff 20)))
+  (let ((cursor-num-updates (try! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 { bytes: bytes, pos: u0 })))
+        (cursor-updates-bytes (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 slice (get next cursor-num-updates) none))
         (updates (get result (fold parse-price-info-and-proof cursor-updates-bytes { 
           result: (list), 
           cursor: {
@@ -159,7 +170,7 @@
     { 
       merkle-root-hash: (get merkle-root-hash acc),
       result: (and (get result acc)
-        (contract-call? .hk-merkle-tree-keccak160-v1 check-proof 
+        (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-merkle-tree-keccak160-v1 check-proof 
           (get merkle-root-hash acc) 
           (get leaf-bytes entry) 
           (get proof entry)))
@@ -191,21 +202,21 @@
     acc
     (if (is-eq (get index (get cursor acc)) (get next-update-index (get cursor acc)))
       ;; Parse update
-      (let ((cursor-update (contract-call? .hk-cursor-v1 new (get bytes acc) (some (get index (get cursor acc)))))
-            (cursor-message-size (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-16 (get next cursor-update))))
-            (cursor-message-type (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-message-size))))
-            (cursor-price-identifier (unwrap-panic (contract-call? .hk-cursor-v1 read-buff-32 (get next cursor-message-type))))
-            (cursor-price (unwrap-panic (contract-call? .hk-cursor-v1 read-int-64 (get next cursor-price-identifier))))
-            (cursor-conf (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-64 (get next cursor-price))))
-            (cursor-expo (unwrap-panic (contract-call? .hk-cursor-v1 read-int-32 (get next cursor-conf))))
-            (cursor-publish-time (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-64 (get next cursor-expo))))
-            (cursor-prev-publish-time (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-64 (get next cursor-publish-time))))
-            (cursor-ema-price (unwrap-panic (contract-call? .hk-cursor-v1 read-int-64 (get next cursor-prev-publish-time))))
-            (cursor-ema-conf (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-64 (get next cursor-ema-price))))
-            (cursor-proof (contract-call? .hk-cursor-v1 advance (get next cursor-message-size) (get value cursor-message-size)))
-            (cursor-proof-size (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-8 cursor-proof)))
-            (proof-bytes (contract-call? .hk-cursor-v1 slice (get next cursor-proof-size) (some (* u20 (get value cursor-proof-size)))))
-            (leaf-bytes (contract-call? .hk-cursor-v1 slice (get next cursor-message-size) (some (get value cursor-message-size))))
+      (let ((cursor-update (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 new (get bytes acc) (some (get index (get cursor acc)))))
+            (cursor-message-size (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-16 (get next cursor-update))))
+            (cursor-message-type (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-message-size))))
+            (cursor-price-identifier (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-32 (get next cursor-message-type))))
+            (cursor-price (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-int-64 (get next cursor-price-identifier))))
+            (cursor-conf (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-price))))
+            (cursor-expo (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-int-32 (get next cursor-conf))))
+            (cursor-publish-time (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-expo))))
+            (cursor-prev-publish-time (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-publish-time))))
+            (cursor-ema-price (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-int-64 (get next cursor-prev-publish-time))))
+            (cursor-ema-conf (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-ema-price))))
+            (cursor-proof (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 advance (get next cursor-message-size) (get value cursor-message-size)))
+            (cursor-proof-size (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 cursor-proof)))
+            (proof-bytes (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 slice (get next cursor-proof-size) (some (* u20 (get value cursor-proof-size)))))
+            (leaf-bytes (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 slice (get next cursor-message-size) (some (get value cursor-message-size))))
             (proof (get result (fold parse-proof proof-bytes { 
               result: (list),
               cursor: {
@@ -215,6 +226,8 @@
               bytes: proof-bytes,
               limit: (get value cursor-proof-size)
             }))))
+        ;; Check cursor-message-type
+        (unwrap-panic (if (is-eq (get value cursor-message-type) u0) (ok true) (err ERR_UPDATE_TYPE)))
         {
           cursor: { 
             index: (+ (get index (get cursor acc)) u1),
@@ -267,8 +280,8 @@
     acc
     (if (is-eq (get index (get cursor acc)) (get next-update-index (get cursor acc)))
       ;; Parse update
-      (let ((cursor-hash (contract-call? .hk-cursor-v1 new (get bytes acc) (some (get index (get cursor acc)))))
-            (hash (get value (unwrap-panic (contract-call? .hk-cursor-v1 read-buff-20 (get next cursor-hash))))))
+      (let ((cursor-hash (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 new (get bytes acc) (some (get index (get cursor acc)))))
+            (hash (get value (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-20 (get next cursor-hash))))))
         ;; Perform assertions
         {
           cursor: { 
diff --git a/contracts/pyth-store-v1.clar b/contracts/pyth-store-v1.clar
index 2b83ea4..760aae2 100644
--- a/contracts/pyth-store-v1.clar
+++ b/contracts/pyth-store-v1.clar
@@ -47,31 +47,22 @@
       publish-time: uint,
       prev-publish-time: uint,
     })) 
-    (if (write-update (get price-identifier entry) {
-          price: (get price entry),
-          conf: (get conf entry),
-          expo: (get expo entry),
-          ema-price: (get ema-price entry),
-          ema-conf: (get ema-conf entry),
-          publish-time: (get publish-time entry),
-          prev-publish-time: (get prev-publish-time entry)
-        })
-        u1
-        u0))
+    (if (is-price-update-more-recent (get price-identifier entry) (get publish-time entry))
+      (begin 
+        (map-set prices 
+          (get price-identifier entry) 
+          {
+            price: (get price entry),
+            conf: (get conf entry),
+            expo: (get expo entry),
+            ema-price: (get ema-price entry),
+            ema-conf: (get ema-conf entry),
+            publish-time: (get publish-time entry),
+            prev-publish-time: (get prev-publish-time entry)
+          })
+        (map-set timestamps (get price-identifier entry) (get publish-time entry))
+        u1)
+      u0))
 
-(define-private (write-update (price-identifier (buff 32)) (data {
-      price: int,
-      conf: uint,
-      expo: int,
-      ema-price: int,
-      ema-conf: uint,
-      publish-time: uint,
-      prev-publish-time: uint,
-    }))
-  (begin
-    (if (not (is-price-update-outdated price-identifier (get publish-time data)))
-      (map-set prices price-identifier data)
-      false)))
-
-(define-private (is-price-update-outdated (price-identifier (buff 32)) (publish-time uint))
-  (< publish-time (default-to u0 (map-get? timestamps price-identifier))))
+(define-private (is-price-update-more-recent (price-identifier (buff 32)) (publish-time uint))
+  (> publish-time (default-to u0 (map-get? timestamps price-identifier))))
diff --git a/contracts/wormhole/wormhole-core-v1.clar b/contracts/wormhole/wormhole-core-v1.clar
index 6d05cf0..b3ad390 100644
--- a/contracts/wormhole/wormhole-core-v1.clar
+++ b/contracts/wormhole/wormhole-core-v1.clar
@@ -69,6 +69,8 @@
 ;; Quorum of addresses required
 (define-constant QUORUM u13)
 
+(define-constant hk-cursor-v2 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2)
+
 ;;;; Data vars
 
 ;; Guardian Set Update uncompressed public keys invalid
@@ -104,11 +106,11 @@
 ;;
 ;; @param vaa-bytes: 
 (define-read-only (parse-vaa (vaa-bytes (buff 8192)))
-  (let ((cursor-version (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 { bytes: vaa-bytes, pos: u0 }) 
-          ERR_VAA_PARSING_VERSION))
-        (cursor-guardian-set-id (unwrap! (contract-call? .hk-cursor-v1 read-uint-32 (get next cursor-version)) 
+  (let ((cursor-version (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 { bytes: vaa-bytes, pos: u0 }) 
+           ERR_VAA_PARSING_VERSION))
+        (cursor-guardian-set-id (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-32 (get next cursor-version)) 
           ERR_VAA_PARSING_GUARDIAN_SET))
-        (cursor-signatures-len (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-guardian-set-id)) 
+        (cursor-signatures-len (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-guardian-set-id)) 
           ERR_VAA_PARSING_SIGNATURES_LEN))
         (cursor-signatures (fold batch-read-signatures
           (list u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0)
@@ -117,21 +119,21 @@
               value: (list),
               iter: (get value cursor-signatures-len)
           }))
-        (vaa-body-hash (keccak256 (keccak256 (get value (unwrap! (contract-call? .hk-cursor-v1 read-buff-8192-max (get next cursor-signatures) none)
+        (vaa-body-hash (keccak256 (keccak256 (get value (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-8192-max (get next cursor-signatures) none)
           ERR_VAA_HASHING_BODY)))))
-        (cursor-timestamp (unwrap! (contract-call? .hk-cursor-v1 read-uint-32 (get next cursor-signatures)) 
+        (cursor-timestamp (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-32 (get next cursor-signatures)) 
           ERR_VAA_PARSING_TIMESTAMP))
-        (cursor-nonce (unwrap! (contract-call? .hk-cursor-v1 read-uint-32 (get next cursor-timestamp)) 
+        (cursor-nonce (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-32 (get next cursor-timestamp)) 
           ERR_VAA_PARSING_NONCE))
-        (cursor-emitter-chain (unwrap! (contract-call? .hk-cursor-v1 read-uint-16 (get next cursor-nonce)) 
+        (cursor-emitter-chain (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-16 (get next cursor-nonce)) 
           ERR_VAA_PARSING_EMITTER_CHAIN))
-        (cursor-emitter-address (unwrap! (contract-call? .hk-cursor-v1 read-buff-32 (get next cursor-emitter-chain)) 
+        (cursor-emitter-address (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-32 (get next cursor-emitter-chain)) 
           ERR_VAA_PARSING_EMITTER_ADDRESS))
-        (cursor-sequence (unwrap! (contract-call? .hk-cursor-v1 read-uint-64 (get next cursor-emitter-address)) 
+        (cursor-sequence (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-64 (get next cursor-emitter-address)) 
           ERR_VAA_PARSING_SEQUENCE))
-        (cursor-consistency-level (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-sequence)) 
+        (cursor-consistency-level (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-sequence)) 
           ERR_VAA_PARSING_CONSISTENCY_LEVEL))
-        (cursor-payload (unwrap! (contract-call? .hk-cursor-v1 read-buff-8192-max (get next cursor-consistency-level) none)
+        (cursor-payload (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-8192-max (get next cursor-consistency-level) none)
           ERR_VAA_PARSING_PAYLOAD))
         (public-keys-results (fold batch-recover-public-keys
           (get value cursor-signatures)
@@ -215,7 +217,7 @@
       }
     })))
 
-(define-public (get-active-guardian-set) 
+(define-read-only (get-active-guardian-set) 
   (let ((set-id (var-get active-guardian-set-id))
         (guardians (unwrap-panic (map-get? guardian-sets { set-id: set-id }))))
       (ok {
@@ -280,8 +282,8 @@
       (acc { next: { bytes: (buff 8192), pos: uint }, iter: uint, value: (list 19 { guardian-id: uint, signature: (buff 65) })}))
   (if (is-eq (get iter acc) u0)
     { iter: u0, next: (get next acc), value: (get value acc) }
-    (let ((cursor-guardian-id (unwrap-panic (contract-call? .hk-cursor-v1 read-uint-8 (get next acc))))
-          (cursor-signature (unwrap-panic (contract-call? .hk-cursor-v1 read-buff-65 (get next cursor-guardian-id)))))
+    (let ((cursor-guardian-id (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next acc))))
+          (cursor-signature (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-65 (get next cursor-guardian-id)))))
       { 
         iter: (- (get iter acc) u1), 
         next: (get next cursor-signature), 
@@ -300,7 +302,7 @@
 
 (define-private (parse-guardian (cue-position uint) (acc { bytes: (buff 8192), result: (list 19 (buff 20))}))
   (let (
-    (cursor-address-bytes (unwrap-panic (contract-call? .hk-cursor-v1 read-buff-20 { bytes: (get bytes acc), pos: cue-position })))
+    (cursor-address-bytes (unwrap-panic (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-20 { bytes: (get bytes acc), pos: cue-position })))
   )
   {
     bytes: (get bytes acc),
@@ -310,17 +312,17 @@
 ;; @desc Parse and verify payload's VAA  
 (define-private (parse-and-verify-guardians-set (bytes (buff 8192)))
   (let 
-      ((cursor-module (unwrap! (contract-call? .hk-cursor-v1 read-buff-32 { bytes: bytes, pos: u0 }) 
+      ((cursor-module (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-32 { bytes: bytes, pos: u0 }) 
           ERR_GSU_PARSING_MODULE))
-      (cursor-action (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-module)) 
+      (cursor-action (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-module)) 
           ERR_GSU_PARSING_ACTION))
-      (cursor-chain (unwrap! (contract-call? .hk-cursor-v1 read-uint-16 (get next cursor-action)) 
+      (cursor-chain (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-16 (get next cursor-action)) 
           ERR_GSU_PARSING_CHAIN))
-      (cursor-new-index (unwrap! (contract-call? .hk-cursor-v1 read-uint-32 (get next cursor-chain)) 
+      (cursor-new-index (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-32 (get next cursor-chain)) 
           ERR_GSU_PARSING_INDEX))
-      (cursor-guardians-count (unwrap! (contract-call? .hk-cursor-v1 read-uint-8 (get next cursor-new-index)) 
+      (cursor-guardians-count (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-uint-8 (get next cursor-new-index)) 
           ERR_GSU_PARSING_GUARDIAN_LEN))
-      (guardians-bytes (unwrap! (contract-call? .hk-cursor-v1 read-buff-8192-max (get next cursor-guardians-count) (some (* (get value cursor-guardians-count) u20))) 
+      (guardians-bytes (unwrap! (contract-call? 'SP2J933XB2CP2JQ1A4FGN8JA968BBG3NK3EKZ7Q9F.hk-cursor-v2 read-buff-8192-max (get next cursor-guardians-count) (some (* (get value cursor-guardians-count) u20))) 
           ERR_GSU_PARSING_GUARDIANS_BYTES))
       (guardians-cues (get result (fold is-guardian-cue (get value guardians-bytes) { cursor: u0, result: (list) })))
       (eth-addresses (get result (fold parse-guardian guardians-cues { bytes: (get value guardians-bytes), result: (list) }))))
diff --git a/package-lock.json b/package-lock.json
index eef980a..f491995 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -377,11 +377,11 @@
       }
     },
     "node_modules/@hirosystems/clarinet-sdk": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-1.0.2.tgz",
-      "integrity": "sha512-++bvBuBdGc0SWYxio+QdVc7U7YL8kydQVth7gnxrGddrS3PcQ+Fgoc/TAwUhdodKk6HMCFpA0+f84KuE6kfe+g==",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-1.0.4.tgz",
+      "integrity": "sha512-jdCNmPSTzdU5s+2lY4lt5fVxn6Hi24JnEyAuBXs5Bfz30qmXwDS7rOTXNGfNMGLS7qgwS9zhR2QXv+uze/7aTg==",
       "dependencies": {
-        "@hirosystems/clarinet-sdk-wasm": "^1.0.4",
+        "@hirosystems/clarinet-sdk-wasm": "^1.0.6",
         "@stacks/transactions": "^6.9.0",
         "kolorist": "^1.8.0",
         "prompts": "^2.4.2",
@@ -396,9 +396,9 @@
       }
     },
     "node_modules/@hirosystems/clarinet-sdk-wasm": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk-wasm/-/clarinet-sdk-wasm-1.0.4.tgz",
-      "integrity": "sha512-8695eWvbKZ2P4/z5LVPWB0e3lT58zVK4eoNDSgGivurpNLrqrkWpFJwauBnBhNo//8enkuvfgedP6CiBVfIZwQ=="
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk-wasm/-/clarinet-sdk-wasm-1.0.7.tgz",
+      "integrity": "sha512-uYd8xobH7XyMcBqkT9V2GHR/baQiFqwUjGOcC7HYNS8amInif48SymkcU+qamBiqGBTd28jyxEtBEUZjtXAIcQ=="
     },
     "node_modules/@jest/schemas": {
       "version": "29.6.3",
@@ -538,30 +538,33 @@
       ]
     },
     "node_modules/@types/bn.js": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.2.tgz",
-      "integrity": "sha512-dkpZu0szUtn9UXTmw+e0AJFd4D2XAxDnsCLdc05SfqpqzPEBft8eQr8uaFitfo/dUUOZERaLec2hHMG87A4Dxg==",
+      "version": "5.1.3",
+      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.3.tgz",
+      "integrity": "sha512-wT1B4iIO82ecXkdN6waCK8Ou7E71WU+mP1osDA5Q8c6Ur+ozU2vIKUIhSpUr6uE5L2YHocKS1Z2jG2fBC1YVeg==",
       "dependencies": {
         "@types/node": "*"
       }
     },
     "node_modules/@types/chai": {
-      "version": "4.3.6",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.6.tgz",
-      "integrity": "sha512-VOVRLM1mBxIRxydiViqPcKn6MIxZytrbMpd6RJLIWKxUNr3zux8no0Oc7kJx0WAPIitgZ0gkrDS+btlqQpubpw=="
+      "version": "4.3.9",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.9.tgz",
+      "integrity": "sha512-69TtiDzu0bcmKQv3yg1Zx409/Kd7r0b5F1PfpYJfSHzLGtB53547V4u+9iqKYsTu/O2ai6KTb0TInNpvuQ3qmg=="
     },
     "node_modules/@types/chai-subset": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.3.tgz",
-      "integrity": "sha512-frBecisrNGz+F4T6bcc+NLeolfiojh5FxW2klu669+8BARtyQv2C/GkNW6FUodVe4BroGMP/wER/YDGc7rEllw==",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.4.tgz",
+      "integrity": "sha512-CCWNXrJYSUIojZ1149ksLl3AN9cmZ5djf+yUoVVV+NuYrtydItQVlL2ZDqyC6M6O9LWRnVf8yYDxbXHO2TfQZg==",
       "dependencies": {
         "@types/chai": "*"
       }
     },
     "node_modules/@types/node": {
-      "version": "18.18.3",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.3.tgz",
-      "integrity": "sha512-0OVfGupTl3NBFr8+iXpfZ8NR7jfFO+P1Q+IO/q0wbo02wYkP5gy36phojeYWpLQ6WAMjl+VfmqUk2YbUfp0irA=="
+      "version": "18.18.7",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.7.tgz",
+      "integrity": "sha512-bw+lEsxis6eqJYW8Ql6+yTqkE6RuFtsQPSe5JxXbqYRFQEER5aJA9a5UH9igqDWm3X4iLHIKOHlnAXLM4mi7uQ==",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
     },
     "node_modules/@vitest/expect": {
       "version": "0.34.6",
@@ -648,9 +651,9 @@
       }
     },
     "node_modules/acorn": {
-      "version": "8.10.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.10.0.tgz",
-      "integrity": "sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==",
+      "version": "8.11.2",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
+      "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -659,9 +662,9 @@
       }
     },
     "node_modules/acorn-walk": {
-      "version": "8.2.0",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz",
-      "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==",
+      "version": "8.3.0",
+      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.0.tgz",
+      "integrity": "sha512-FS7hV565M5l1R08MXqo8odwMTB02C2UqzB17RVgu9EyuYFBqJZ3/ZY97sQD5FewVu1UyDFc1yztUDrAwT0EypA==",
       "engines": {
         "node": ">=0.4.0"
       }
@@ -866,21 +869,6 @@
         "wrap-ansi": "^5.1.0"
       }
     },
-    "node_modules/chokidar-cli/node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-      "dev": true,
-      "dependencies": {
-        "color-name": "1.1.3"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
-      "dev": true
-    },
     "node_modules/chokidar-cli/node_modules/emoji-regex": {
       "version": "7.0.3",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
@@ -984,20 +972,19 @@
       }
     },
     "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
       "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
+        "color-name": "1.1.3"
       }
     },
     "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
+      "dev": true
     },
     "node_modules/cross-fetch": {
       "version": "3.1.8",
@@ -1101,9 +1088,9 @@
       }
     },
     "node_modules/fast-check": {
-      "version": "3.13.1",
-      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.13.1.tgz",
-      "integrity": "sha512-Xp00tFuWd83i8rbG/4wU54qU+yINjQha7bXH2N4ARNTkyOimzHtUBJ5+htpdXk7RMaCOD/j2jxSjEt9u9ZPNeQ==",
+      "version": "3.13.2",
+      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.13.2.tgz",
+      "integrity": "sha512-ouTiFyeMoqmNg253xqy4NSacr5sHxH6pZpLOaHgaAdgZxFWdtsfxExwolpveoAE9CJdV+WYjqErNGef6SqA5Mg==",
       "dev": true,
       "funding": [
         {
@@ -1334,17 +1321,17 @@
       "dev": true
     },
     "node_modules/loupe": {
-      "version": "2.3.6",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz",
-      "integrity": "sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA==",
+      "version": "2.3.7",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.7.tgz",
+      "integrity": "sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==",
       "dependencies": {
-        "get-func-name": "^2.0.0"
+        "get-func-name": "^2.0.1"
       }
     },
     "node_modules/magic-string": {
-      "version": "0.30.4",
-      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.4.tgz",
-      "integrity": "sha512-Q/TKtsC5BPm0kGqgBIF9oXAs/xEf2vRKiIB4wCRQTJOQIByZ1d+NnUOotvJOvNpi5RNIgVOMC3pOuaP1ZTDlVg==",
+      "version": "0.30.5",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.5.tgz",
+      "integrity": "sha512-7xlpfBaQaP/T6Vh8MO/EqXSW5En6INHEvEXQiuff7Gku0PWjU3uf6w/j9o7O+SpB5fOAkrI5HeoNgwjEO0pFsA==",
       "dependencies": {
         "@jridgewell/sourcemap-codec": "^1.4.15"
       },
@@ -1868,10 +1855,15 @@
       "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.3.1.tgz",
       "integrity": "sha512-uY/99gMLIOlJPwATcMVYfqDSxUR9//AUcgZMzwfSTJPDKzA1S8mX4VLqa+fiAtveraQUBCz4FFcwVZBGbwBXIw=="
     },
+    "node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="
+    },
     "node_modules/vite": {
-      "version": "4.4.11",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-4.4.11.tgz",
-      "integrity": "sha512-ksNZJlkcU9b0lBwAGZGGaZHCMqHsc8OpgtoYhsQ4/I2v5cnpmmmqe5pM4nv/4Hn6G/2GhTdj0DhZh2e+Er1q5A==",
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.0.tgz",
+      "integrity": "sha512-ulr8rNLA6rkyFAlVWw2q5YJ91v098AFQ2R0PRFwPzREXOUJQPtFUG0t+/ZikhaOCDqFoDhN6/v8Sq0o4araFAw==",
       "dependencies": {
         "esbuild": "^0.18.10",
         "postcss": "^8.4.27",
@@ -2094,6 +2086,22 @@
         "url": "https://github.com/chalk/ansi-styles?sponsor=1"
       }
     },
+    "node_modules/wrap-ansi/node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+    },
     "node_modules/y18n": {
       "version": "5.0.8",
       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
diff --git a/unit-tests/pyth/helpers.ts b/unit-tests/pyth/helpers.ts
index 94e6ecf..9ff6150 100644
--- a/unit-tests/pyth/helpers.ts
+++ b/unit-tests/pyth/helpers.ts
@@ -4,9 +4,7 @@ import {
   ClarityValue,
   contractPrincipalCV,
   cvToHex,
-  cvToValue,
   principalCV,
-  publicKeyToAddress,
 } from "@stacks/transactions";
 import { bigintToBuffer, bufferToBigint } from "../utils/helpers";
 import * as secp from "@noble/secp256k1";
@@ -17,6 +15,8 @@ if (!globalThis.crypto) globalThis.crypto = webcrypto;
 
 import { hmac } from "@noble/hashes/hmac";
 import { sha256 } from "@noble/hashes/sha256";
+import { wormhole } from "../wormhole/helpers";
+import { hexToBytes } from "@noble/hashes/utils";
 
 secp.etc.hmacSha256Sync = (k, ...m) =>
   hmac(sha256, k, secp.etc.concatBytes(...m));
@@ -55,6 +55,36 @@ export namespace pyth {
     "hex",
   );
 
+  export const PnauMagicBytes = new Uint8Array(Buffer.from("504e4155", "hex"));
+  export const AuwvMagicBytes = new Uint8Array(Buffer.from("41555756", "hex"));
+  export const PgtmMagicBytes = new Uint8Array(Buffer.from("5054474d", "hex"));
+  export const InitialGovernanceDataSource = {
+    chain: 0,
+    address: hexToBytes(
+      "0000000000000000000000000000000000000000000000000000000000000000",
+    ),
+  };
+  export const DefaultGovernanceDataSource = {
+    chain: 1,
+    address: hexToBytes(
+      "0000000000000000000000000000000000000000000000000000000000000001",
+    ),
+  };
+  export const DefaultPricesDataSources = [
+    {
+      chain: 2,
+      address: hexToBytes(
+        "0000000000000000000000000000000000000000000000000000000000000004",
+      ),
+    },
+    {
+      chain: 3,
+      address: hexToBytes(
+        "0000000000000000000000000000000000000000000000000000000000000006",
+      ),
+    },
+  ];
+
   export interface PriceUpdate {
     priceIdentifier: Uint8Array;
     price: bigint;
@@ -96,12 +126,15 @@ export namespace pyth {
     magicBytes: Uint8Array;
     module: number;
     action: number;
-    chainId: number;
+    targetChainId: number;
     updateFeeValue?: PtgmUpdateFeeValue;
     updateFeeRecipient?: PtgmUpdateFeeRecipient;
-    updateWormholeContract?: PtgmUpdateWormholeContract;
-    updateOracleContract?: PtgmUpdateOracleContract;
-    updatePricesDataSources?: PtgmUpdatePriceDataSource[];
+    updateWormholeContract?: PtgmUpdateContract;
+    updateOracleContract?: PtgmUpdateContract;
+    updateStoreContract?: PtgmUpdateContract;
+    updateDecoderContract?: PtgmUpdateContract;
+    updatePricesDataSources?: wormhole.Emitter[];
+    updateGovernanceDataSource?: wormhole.Emitter;
   }
 
   export interface PtgmUpdateFeeValue {
@@ -109,22 +142,12 @@ export namespace pyth {
     exponent: bigint;
   }
 
-  export interface PtgmUpdatePriceDataSource {
-    chain: number;
-    address: Uint8Array;
-  }
-
   export interface PtgmUpdateFeeRecipient {
     address: string;
     contractName?: string;
   }
 
-  export interface PtgmUpdateWormholeContract {
-    address: string;
-    contractName: string;
-  }
-
-  export interface PtgmUpdateOracleContract {
+  export interface PtgmUpdateContract {
     address: string;
     contractName: string;
   }
@@ -133,12 +156,15 @@ export namespace pyth {
     magicBytes?: Uint8Array;
     module?: number;
     action?: number;
-    chainId?: number;
+    targetChainId?: number;
     updateFeeValue?: PtgmUpdateFeeValue;
     updateFeeRecipient?: PtgmUpdateFeeRecipient;
-    updateWormholeContract?: PtgmUpdateWormholeContract;
-    updatePricesDataSources?: PtgmUpdatePriceDataSource[];
-    updateOracleContract?: PtgmUpdateOracleContract;
+    updatePricesDataSources?: wormhole.Emitter[];
+    updateWormholeContract?: PtgmUpdateContract;
+    updateOracleContract?: PtgmUpdateContract;
+    updateStoreContract?: PtgmUpdateContract;
+    updateDecoderContract?: PtgmUpdateContract;
+    updateGovernanceDataSource?: wormhole.Emitter;
   }
 
   export interface PnauHeader {
@@ -239,22 +265,30 @@ export namespace pyth {
       action = 0x00;
     } else if (opts?.updateWormholeContract) {
       action = 0x06;
+    } else if (opts?.updateDecoderContract) {
+      action = 0xa2;
+    } else if (opts?.updateStoreContract) {
+      action = 0xa1;
     } else if (opts?.updatePricesDataSources) {
       action = 0x02;
+    } else if (opts?.updateGovernanceDataSource) {
+      action = 0x01;
     } else {
       throw "PTGM action unsupported";
     }
     return {
-      magicBytes:
-        opts?.magicBytes || new Uint8Array(Buffer.from("5054474d", "hex")),
+      magicBytes: opts?.magicBytes || PgtmMagicBytes,
       action,
-      chainId: opts?.chainId || 0,
+      targetChainId: opts?.targetChainId || 0,
       module: opts?.module || 0,
       updateFeeRecipient: opts?.updateFeeRecipient,
       updateFeeValue: opts?.updateFeeValue,
       updateOracleContract: opts?.updateOracleContract,
       updateWormholeContract: opts?.updateWormholeContract,
       updatePricesDataSources: opts?.updatePricesDataSources,
+      updateDecoderContract: opts?.updateDecoderContract,
+      updateGovernanceDataSource: opts?.updateGovernanceDataSource,
+      updateStoreContract: opts?.updateStoreContract,
     };
   }
 
@@ -273,8 +307,8 @@ export namespace pyth {
     v.writeUint8(payload.action, 0);
     components.push(v);
     // Chain id
-    v = Buffer.alloc(2);
-    v.writeUint8(payload.chainId, 0);
+    v = Buffer.alloc(1);
+    v.writeUint8(payload.targetChainId, 0);
     components.push(v);
 
     if (payload.updateFeeValue) {
@@ -303,6 +337,25 @@ export namespace pyth {
         payload.updateWormholeContract.contractName,
       );
       components.push(clarityValueToBuffer(principal));
+    } else if (payload.updateStoreContract) {
+      let principal = contractPrincipalCV(
+        payload.updateStoreContract.address,
+        payload.updateStoreContract.contractName,
+      );
+      components.push(clarityValueToBuffer(principal));
+    } else if (payload.updateDecoderContract) {
+      let principal = contractPrincipalCV(
+        payload.updateDecoderContract.address,
+        payload.updateDecoderContract.contractName,
+      );
+      components.push(clarityValueToBuffer(principal));
+    } else if (payload.updateGovernanceDataSource) {
+      // Chain id
+      v = Buffer.alloc(2);
+      v.writeUint16BE(payload.updateGovernanceDataSource.chain, 0);
+      components.push(v);
+      // Address
+      components.push(payload.updateGovernanceDataSource.address);
     } else if (payload.updatePricesDataSources) {
       // Nuber of updates
       v = Buffer.alloc(1);
@@ -311,8 +364,8 @@ export namespace pyth {
 
       for (let dataSource of payload.updatePricesDataSources) {
         // Chain
-        v = Buffer.alloc(1);
-        v.writeUint8(dataSource.chain, 0);
+        v = Buffer.alloc(2);
+        v.writeUint16BE(dataSource.chain, 0);
         components.push(v);
         // Address
         components.push(dataSource.address);
@@ -379,7 +432,7 @@ export namespace pyth {
 
   export function buildAuwvVaaPayload(
     batch: PriceUpdateBatch,
-    merkleRootData?: AuwvVaaPayloadBuildOptions,
+    auwvBuildOptions?: AuwvVaaPayloadBuildOptions,
   ) {
     let merkleLeaves = [...batch.hashed];
     // Compute merkle tree
@@ -396,20 +449,17 @@ export namespace pyth {
     }
 
     return {
-      payloadType:
-        merkleRootData?.payloadType ||
-        new Uint8Array(Buffer.from("41555756", "hex")),
-      updateType: merkleRootData?.updateType || 0,
-      merkleRootRingSize: merkleRootData?.merkleRootRingSize || 0,
-      merkleRootSlot: merkleRootData?.merkleRootSlot || 0n,
+      payloadType: auwvBuildOptions?.payloadType || AuwvMagicBytes,
+      updateType: auwvBuildOptions?.updateType || 0,
+      merkleRootRingSize: auwvBuildOptions?.merkleRootRingSize || 0,
+      merkleRootSlot: auwvBuildOptions?.merkleRootSlot || 0n,
       merkleRootHash: merkleLeaves[0],
     };
   }
 
   export function buildPnauHeader(opts?: PnauHeaderBuildOptions) {
     return {
-      magicBytes:
-        opts?.magicBytes || new Uint8Array(Buffer.from("504e4155", "hex")),
+      magicBytes: opts?.magicBytes || PnauMagicBytes,
       versionMaj: opts?.versionMaj || 1,
       versionMin: opts?.versionMin || 0,
       trailingSize: opts?.trailingSize || 0,
@@ -532,6 +582,72 @@ export namespace pyth {
     };
   }
 
+  export function applyGovernanceDataSourceUpdate(
+    updateGovernanceDataSource: wormhole.Emitter,
+    emitter: wormhole.Emitter,
+    guardianSet: wormhole.Guardian[],
+    txSenderAddress: string,
+    pythGovernanceContractName: string,
+    wormholeCoreContractName: string,
+    sequence: bigint,
+  ) {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload, sequence, emitter });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-governance-data-source`,
+      [Cl.buffer(vaa), wormholeContract],
+      txSenderAddress,
+    );
+
+    return res;
+  }
+
+  export function applyPricesDataSourceUpdate(
+    updatePricesDataSources: wormhole.Emitter[],
+    emitter: wormhole.Emitter,
+    guardianSet: wormhole.Guardian[],
+    txSenderAddress: string,
+    pythGovernanceContractName: string,
+    wormholeCoreContractName: string,
+    sequence: bigint,
+  ) {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({ updatePricesDataSources });
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload, sequence, emitter });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-prices-data-sources`,
+      [Cl.buffer(vaa), wormholeContract],
+      txSenderAddress,
+    );
+
+    return res;
+  }
+
   export namespace fc_ext {
     export const priceUpdate = (opts?: PriceUpdateBuildOptions) => {
       // price
diff --git a/unit-tests/pyth/oracle.test.ts b/unit-tests/pyth/oracle.test.ts
index fa9d04d..8fb5629 100644
--- a/unit-tests/pyth/oracle.test.ts
+++ b/unit-tests/pyth/oracle.test.ts
@@ -30,7 +30,7 @@ describe("pyth-oracle-v1::decode-and-verify-price-feeds mainnet VAAs", () => {
     });
   });
 
-  it("should succeed handling PNAU mainnet payloads", () => {
+  it.skip("should succeed handling PNAU mainnet payloads", () => {
     const pnauBytes = Cl.bufferFromHex(pnauMainnetVaas[0]);
     let priceIdentifier = Cl.bufferFromHex(
       "ec7a775f46379b5e943c3526b1c8d54cd49749176b0b98e02dde68d1bd335c17",
diff --git a/unit-tests/pyth/pnau.test.ts b/unit-tests/pyth/pnau.test.ts
index 8de0686..c2afd7f 100644
--- a/unit-tests/pyth/pnau.test.ts
+++ b/unit-tests/pyth/pnau.test.ts
@@ -5,6 +5,7 @@ import { pyth } from "./helpers";
 
 const pythOracleContractName = "pyth-oracle-v1";
 const pythDecoderPnauContractName = "pyth-pnau-decoder-v1";
+const pythGovernanceContractName = "pyth-governance-v1";
 const pythStorageContractName = "pyth-store-v1";
 const wormholeCoreContractName = "wormhole-core-v1";
 
@@ -37,11 +38,34 @@ describe("pyth-pnau-decoder-v1::decode-and-verify-price-feeds success", () => {
       sender,
       wormholeCoreContractName,
     );
+
+    pyth.applyGovernanceDataSourceUpdate(
+      pyth.DefaultGovernanceDataSource,
+      pyth.InitialGovernanceDataSource,
+      guardianSet,
+      sender,
+      pythGovernanceContractName,
+      wormholeCoreContractName,
+      2n,
+    );
+
+    pyth.applyPricesDataSourceUpdate(
+      pyth.DefaultPricesDataSources,
+      pyth.DefaultGovernanceDataSource,
+      guardianSet,
+      sender,
+      pythGovernanceContractName,
+      wormholeCoreContractName,
+      3n,
+    );
   });
 
-  it("should parse and verify the Vaa a a Pnau message", () => {
+  it("should parse and verify the Vaa a Pnau message", () => {
     let payload = pyth.serializeAuwvVaaPayloadToBuffer(pricesUpdatesVaaPayload);
-    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
     let header = wormhole.buildValidVaaHeader(guardianSet, body, {
       version: 1,
       guardianSetId: 1,
@@ -64,7 +88,11 @@ describe("pyth-pnau-decoder-v1::decode-and-verify-price-feeds success", () => {
 
   it("should produce a correct verifiable empty vaa", () => {
     let payload = pyth.serializeAuwvVaaPayloadToBuffer(pricesUpdatesVaaPayload);
-    let vaaBody = wormhole.buildValidVaaBodySpecs({ payload });
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+
     let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
       version: 1,
       guardianSetId: 1,
@@ -101,3 +129,496 @@ describe("pyth-pnau-decoder-v1::decode-and-verify-price-feeds success", () => {
     expect(res.result).toHaveClarityType(ClarityType.ResponseOk);
   });
 });
+
+describe("pyth-pnau-decoder-v1::decode-and-verify-price-feeds failures", () => {
+  const accounts = simnet.getAccounts();
+  const sender = accounts.get("wallet_1")!;
+  const guardianSet = wormhole.generateGuardianSetKeychain(19);
+  let pricesUpdates = pyth.buildPriceUpdateBatch([
+    [pyth.BtcPriceIdentifier],
+    [pyth.StxPriceIdentifier],
+    [pyth.BatPriceIdentifer],
+    [pyth.DaiPriceIdentifer],
+    [pyth.TbtcPriceIdentifer],
+    [pyth.UsdcPriceIdentifer],
+    [pyth.UsdtPriceIdentifer],
+    [pyth.WbtcPriceIdentifer],
+  ]);
+  let pricesUpdatesToSubmit = [
+    pyth.BtcPriceIdentifier,
+    pyth.StxPriceIdentifier,
+    pyth.UsdcPriceIdentifer,
+  ];
+  let pricesUpdatesVaaPayload = pyth.buildAuwvVaaPayload(pricesUpdates);
+  let executionPlan = Cl.tuple({
+    "pyth-storage-contract": Cl.contractPrincipal(
+      simnet.deployer,
+      pythStorageContractName,
+    ),
+    "pyth-decoder-contract": Cl.contractPrincipal(
+      simnet.deployer,
+      pythDecoderPnauContractName,
+    ),
+    "wormhole-core-contract": Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    ),
+  });
+
+  // Before starting the test suite, we have to setup the guardian set and propagate one update
+  beforeEach(async () => {
+    wormhole.applyGuardianSetUpdate(
+      guardianSet,
+      1,
+      sender,
+      wormholeCoreContractName,
+    );
+
+    pyth.applyGovernanceDataSourceUpdate(
+      pyth.DefaultGovernanceDataSource,
+      pyth.InitialGovernanceDataSource,
+      guardianSet,
+      sender,
+      pythGovernanceContractName,
+      wormholeCoreContractName,
+      2n,
+    );
+
+    pyth.applyPricesDataSourceUpdate(
+      pyth.DefaultPricesDataSources,
+      pyth.DefaultGovernanceDataSource,
+      guardianSet,
+      sender,
+      pythGovernanceContractName,
+      wormholeCoreContractName,
+      3n,
+    );
+
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(pricesUpdatesVaaPayload);
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader();
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    pricesUpdates.decoded[0];
+
+    simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+  });
+
+  it("should succeed updating prices once", () => {
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "read-price-feed",
+      [
+        Cl.buffer(pyth.BtcPriceIdentifier),
+        Cl.contractPrincipal(simnet.deployer, pythStorageContractName),
+      ],
+      sender,
+    );
+    expect(res.result).toBeOk(
+      Cl.tuple({
+        price: Cl.int(pricesUpdates.decoded[0].price),
+        conf: Cl.uint(pricesUpdates.decoded[0].conf),
+        "ema-conf": Cl.uint(pricesUpdates.decoded[0].emaConf),
+        "ema-price": Cl.int(pricesUpdates.decoded[0].emaPrice),
+        expo: Cl.int(pricesUpdates.decoded[0].expo),
+        "prev-publish-time": Cl.uint(pricesUpdates.decoded[0].prevPublishTime),
+        "publish-time": Cl.uint(pricesUpdates.decoded[0].publishTime),
+      }),
+    );
+  });
+
+  it("should fail storing outdated subsequent updates", () => {
+    let outdatedPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 0n, publishTime: 9999999n }],
+      [pyth.StxPriceIdentifier],
+      [pyth.BatPriceIdentifer],
+      [pyth.DaiPriceIdentifer],
+      [pyth.TbtcPriceIdentifer],
+      [pyth.UsdcPriceIdentifer],
+      [pyth.UsdtPriceIdentifer],
+      [pyth.WbtcPriceIdentifer],
+    ]);
+    let outdatedPricesUpdatesVaaPayload = pyth.buildAuwvVaaPayload(
+      outdatedPricesUpdates,
+    );
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      outdatedPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader();
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: outdatedPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+
+    res = simnet.callPublicFn(
+      pythOracleContractName,
+      "read-price-feed",
+      [
+        Cl.buffer(pyth.BtcPriceIdentifier),
+        Cl.contractPrincipal(simnet.deployer, pythStorageContractName),
+      ],
+      sender,
+    );
+    expect(res.result).toBeOk(
+      Cl.tuple({
+        price: Cl.int(pricesUpdates.decoded[0].price),
+        conf: Cl.uint(pricesUpdates.decoded[0].conf),
+        "ema-conf": Cl.uint(pricesUpdates.decoded[0].emaConf),
+        "ema-price": Cl.int(pricesUpdates.decoded[0].emaPrice),
+        expo: Cl.int(pricesUpdates.decoded[0].expo),
+        "prev-publish-time": Cl.uint(pricesUpdates.decoded[0].prevPublishTime),
+        "publish-time": Cl.uint(pricesUpdates.decoded[0].publishTime),
+      }),
+    );
+  });
+
+  it("should succeed storing new subsequent updates", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+      [pyth.StxPriceIdentifier],
+      [pyth.BatPriceIdentifer],
+      [pyth.DaiPriceIdentifer],
+      [pyth.TbtcPriceIdentifer],
+      [pyth.UsdcPriceIdentifer],
+      [pyth.UsdtPriceIdentifer],
+      [pyth.WbtcPriceIdentifer],
+    ]);
+    let actualPricesUpdatesVaaPayload =
+      pyth.buildAuwvVaaPayload(actualPricesUpdates);
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader();
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+
+    res = simnet.callPublicFn(
+      pythOracleContractName,
+      "read-price-feed",
+      [
+        Cl.buffer(pyth.BtcPriceIdentifier),
+        Cl.contractPrincipal(simnet.deployer, pythStorageContractName),
+      ],
+      sender,
+    );
+    expect(res.result).toBeOk(
+      Cl.tuple({
+        price: Cl.int(actualPricesUpdates.decoded[0].price),
+        conf: Cl.uint(actualPricesUpdates.decoded[0].conf),
+        "ema-conf": Cl.uint(actualPricesUpdates.decoded[0].emaConf),
+        "ema-price": Cl.int(actualPricesUpdates.decoded[0].emaPrice),
+        expo: Cl.int(actualPricesUpdates.decoded[0].expo),
+        "prev-publish-time": Cl.uint(
+          actualPricesUpdates.decoded[0].prevPublishTime,
+        ),
+        "publish-time": Cl.uint(actualPricesUpdates.decoded[0].publishTime),
+      }),
+    );
+  });
+
+  it("should fail if AUWV payloadType is incorrect", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+    ]);
+    let actualPricesUpdatesVaaPayload = pyth.buildAuwvVaaPayload(
+      actualPricesUpdates,
+      { payloadType: Buffer.from("41555755", "hex") },
+    );
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader();
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(2001));
+  });
+
+  it("should fail if AUWV updateType is incorrect", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+    ]);
+    let actualPricesUpdatesVaaPayload = pyth.buildAuwvVaaPayload(
+      actualPricesUpdates,
+      { updateType: 1 },
+    );
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader();
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(2005));
+  });
+
+  it("should fail if PNAU magic bytes is incorrect", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+    ]);
+    let actualPricesUpdatesVaaPayload =
+      pyth.buildAuwvVaaPayload(actualPricesUpdates);
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader({
+      magicBytes: Buffer.from("41555755", "hex"),
+    });
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(2001));
+  });
+
+  it("should fail if PNAU major version is incorrect", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+    ]);
+    let actualPricesUpdatesVaaPayload =
+      pyth.buildAuwvVaaPayload(actualPricesUpdates);
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader({
+      versionMaj: 5,
+    });
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(2002));
+  });
+
+  it("should fail if PNAU minor version is incorrect", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+    ]);
+    let actualPricesUpdatesVaaPayload =
+      pyth.buildAuwvVaaPayload(actualPricesUpdates);
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader({
+      versionMin: 5,
+    });
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(2003));
+  });
+
+  it("should fail if PNAU proof type version is incorrect", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+    ]);
+    let actualPricesUpdatesVaaPayload =
+      pyth.buildAuwvVaaPayload(actualPricesUpdates);
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader({
+      proofType: 5,
+    });
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(2005));
+  });
+
+  it("should fail if PNAU include Merkle root mismatches", () => {
+    let actualPricesUpdates = pyth.buildPriceUpdateBatch([
+      [pyth.BtcPriceIdentifier, { price: 100n, publishTime: 10000003n }],
+    ]);
+    let actualPricesUpdatesVaaPayload =
+      pyth.buildAuwvVaaPayload(actualPricesUpdates);
+    actualPricesUpdatesVaaPayload.merkleRootHash = new Uint8Array(
+      Buffer.alloc(32),
+    );
+    let payload = pyth.serializeAuwvVaaPayloadToBuffer(
+      actualPricesUpdatesVaaPayload,
+    );
+    let vaaBody = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultPricesDataSources[0],
+    });
+    let vaaHeader = wormhole.buildValidVaaHeader(guardianSet, vaaBody, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(vaaHeader, vaaBody);
+    let pnauHeader = pyth.buildPnauHeader();
+    let pnau = pyth.serializePnauToBuffer(pnauHeader, {
+      vaa,
+      pricesUpdates: actualPricesUpdates,
+      pricesUpdatesToSubmit,
+    });
+
+    let res = simnet.callPublicFn(
+      pythOracleContractName,
+      "verify-and-update-price-feeds",
+      [Cl.buffer(pnau), executionPlan],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(2008));
+  });
+});
diff --git a/unit-tests/pyth/ptgm.test.ts b/unit-tests/pyth/ptgm.test.ts
index 6932ae5..f312634 100644
--- a/unit-tests/pyth/ptgm.test.ts
+++ b/unit-tests/pyth/ptgm.test.ts
@@ -2,6 +2,7 @@ import { Cl } from "@stacks/transactions";
 import { beforeEach, describe, expect, it } from "vitest";
 import { wormhole } from "../wormhole/helpers";
 import { pyth } from "./helpers";
+import { hexToBytes } from "@noble/hashes/utils";
 
 const pythOracleContractName = "pyth-oracle-v1";
 const pythStorageContractName = "pyth-store-v1";
@@ -71,6 +72,29 @@ describe("pyth-governance-v1::update-fee-value", () => {
       }),
     );
   });
+
+  it("should fail if action mismatches", () => {
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-fee-value`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
+  });
 });
 
 describe("pyth-governance-v1::update-fee-recipient", () => {
@@ -127,6 +151,29 @@ describe("pyth-governance-v1::update-fee-recipient", () => {
       }),
     );
   });
+
+  it("should fail if action mismatches", () => {
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-fee-recipient-address`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
+  });
 });
 
 describe("pyth-governance-v1::update-wormhole-core-contract", () => {
@@ -196,6 +243,308 @@ describe("pyth-governance-v1::update-wormhole-core-contract", () => {
       sender,
     );
     expect(Cl.ok(res.result)).toBeOk(executionPlan);
+
+    // Any future call from the now outdated v1 contract should be rejected
+    let executionPlanBase = {
+      "pyth-decoder-contract": Cl.contractPrincipal(
+        deployer,
+        pythDecoderPnauContractName,
+      ),
+      "pyth-storage-contract": Cl.contractPrincipal(
+        deployer,
+        pythStorageContractName,
+      ),
+      "wormhole-core-contract": Cl.contractPrincipal(
+        deployer,
+        wormholeCoreContractName,
+      ),
+    };
+    res = simnet.callPublicFn(
+      pythOracleContractName,
+      `verify-and-update-price-feeds`,
+      [Cl.bufferFromHex("00"), Cl.tuple(executionPlanBase)],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4004));
+  });
+
+  it("should fail if action mismatches", () => {
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-wormhole-core-contract`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
+  });
+});
+
+describe("pyth-governance-v1::update-pyth-decoder-contract", () => {
+  const accounts = simnet.getAccounts();
+  const sender = accounts.get("wallet_1")!;
+  const deployer = accounts.get("deployer")!;
+  const guardianSet = wormhole.generateGuardianSetKeychain(19);
+  let updateDecoderContract = {
+    address: "ST2CY5V39NHDPWSXMW9QDT3HC3GD6Q6XX4CFRK9AG",
+    contractName: "pyth-decoder-v2",
+  };
+  let ptgmVaaPayload = pyth.buildPtgmVaaPayload({ updateDecoderContract });
+
+  // Before starting the test suite, we have to setup the guardian set.
+  beforeEach(async () => {
+    wormhole.applyGuardianSetUpdate(
+      guardianSet,
+      1,
+      sender,
+      wormholeCoreContractName,
+    );
+  });
+
+  it("should update the execution plan on successful updates", () => {
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-pyth-decoder-contract`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    let executionPlan = Cl.tuple({
+      "pyth-oracle-contract": Cl.contractPrincipal(
+        deployer,
+        pythOracleContractName,
+      ),
+      "pyth-decoder-contract": Cl.contractPrincipal(
+        updateDecoderContract.address,
+        updateDecoderContract.contractName,
+      ),
+      "pyth-storage-contract": Cl.contractPrincipal(
+        deployer,
+        pythStorageContractName,
+      ),
+      "wormhole-core-contract": Cl.contractPrincipal(
+        deployer,
+        wormholeCoreContractName,
+      ),
+    });
+    expect(res.result).toBeOk(executionPlan);
+
+    res = simnet.callReadOnlyFn(
+      pythGovernanceContractName,
+      `get-current-execution-plan`,
+      [],
+      sender,
+    );
+    expect(Cl.ok(res.result)).toBeOk(executionPlan);
+
+    // Any future call from the now outdated v1 contract should be rejected
+    let executionPlanBase = {
+      "pyth-decoder-contract": Cl.contractPrincipal(
+        deployer,
+        pythDecoderPnauContractName,
+      ),
+      "pyth-storage-contract": Cl.contractPrincipal(
+        deployer,
+        pythStorageContractName,
+      ),
+      "wormhole-core-contract": Cl.contractPrincipal(
+        deployer,
+        wormholeCoreContractName,
+      ),
+    };
+    res = simnet.callPublicFn(
+      pythOracleContractName,
+      `verify-and-update-price-feeds`,
+      [Cl.bufferFromHex("00"), Cl.tuple(executionPlanBase)],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4004));
+  });
+
+  it("should not be callable directly", () => {
+    let res = simnet.callPublicFn(
+      pythDecoderPnauContractName,
+      `decode-and-verify-price-feeds`,
+      [
+        Cl.bufferFromHex("00"),
+        Cl.contractPrincipal(deployer, wormholeCoreContractName),
+      ],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4004));
+  });
+
+  it("should fail if action mismatches", () => {
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-pyth-decoder-contract`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
+  });
+});
+
+describe("pyth-governance-v1::update-pyth-store-contract", () => {
+  const accounts = simnet.getAccounts();
+  const sender = accounts.get("wallet_1")!;
+  const deployer = accounts.get("deployer")!;
+  const guardianSet = wormhole.generateGuardianSetKeychain(19);
+  let updateStoreContract = {
+    address: "ST2CY5V39NHDPWSXMW9QDT3HC3GD6Q6XX4CFRK9AG",
+    contractName: "pyth-store-v2",
+  };
+  let ptgmVaaPayload = pyth.buildPtgmVaaPayload({ updateStoreContract });
+
+  // Before starting the test suite, we have to setup the guardian set.
+  beforeEach(async () => {
+    wormhole.applyGuardianSetUpdate(
+      guardianSet,
+      1,
+      sender,
+      wormholeCoreContractName,
+    );
+  });
+
+  it("should update the execution plan on successful updates", () => {
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-pyth-store-contract`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    let executionPlan = Cl.tuple({
+      "pyth-oracle-contract": Cl.contractPrincipal(
+        deployer,
+        pythOracleContractName,
+      ),
+      "pyth-decoder-contract": Cl.contractPrincipal(
+        deployer,
+        pythDecoderPnauContractName,
+      ),
+      "pyth-storage-contract": Cl.contractPrincipal(
+        updateStoreContract.address,
+        updateStoreContract.contractName,
+      ),
+      "wormhole-core-contract": Cl.contractPrincipal(
+        deployer,
+        wormholeCoreContractName,
+      ),
+    });
+    expect(res.result).toBeOk(executionPlan);
+
+    res = simnet.callReadOnlyFn(
+      pythGovernanceContractName,
+      `get-current-execution-plan`,
+      [],
+      sender,
+    );
+    expect(Cl.ok(res.result)).toBeOk(executionPlan);
+
+    // Any future call from the now outdated v1 contract should be rejected
+    let executionPlanBase = {
+      "pyth-decoder-contract": Cl.contractPrincipal(
+        deployer,
+        pythDecoderPnauContractName,
+      ),
+      "pyth-storage-contract": Cl.contractPrincipal(
+        deployer,
+        pythStorageContractName,
+      ),
+      "wormhole-core-contract": Cl.contractPrincipal(
+        deployer,
+        wormholeCoreContractName,
+      ),
+    };
+    res = simnet.callPublicFn(
+      pythOracleContractName,
+      `verify-and-update-price-feeds`,
+      [Cl.bufferFromHex("00"), Cl.tuple(executionPlanBase)],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4004));
+
+    res = simnet.callPublicFn(
+      pythOracleContractName,
+      `read-price-feed`,
+      [
+        Cl.bufferFromHex("00"),
+        Cl.contractPrincipal(deployer, pythStorageContractName),
+      ],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4004));
+  });
+
+  it("should fail if action mismatches", () => {
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-pyth-store-contract`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
   });
 });
 
@@ -239,11 +588,7 @@ describe("pyth-governance-v1::update-pyth-oracle-contract", () => {
       [Cl.buffer(vaa), wormholeContract],
       sender,
     );
-    let executionPlan = Cl.tuple({
-      "pyth-oracle-contract": Cl.contractPrincipal(
-        updateOracleContract.address,
-        updateOracleContract.contractName,
-      ),
+    let executionPlanBase = {
       "pyth-decoder-contract": Cl.contractPrincipal(
         deployer,
         pythDecoderPnauContractName,
@@ -256,6 +601,14 @@ describe("pyth-governance-v1::update-pyth-oracle-contract", () => {
         deployer,
         wormholeCoreContractName,
       ),
+    };
+
+    let executionPlan = Cl.tuple({
+      "pyth-oracle-contract": Cl.contractPrincipal(
+        updateOracleContract.address,
+        updateOracleContract.contractName,
+      ),
+      ...executionPlanBase,
     });
     expect(res.result).toBeOk(executionPlan);
 
@@ -266,6 +619,38 @@ describe("pyth-governance-v1::update-pyth-oracle-contract", () => {
       sender,
     );
     expect(Cl.ok(res.result)).toBeOk(executionPlan);
+
+    // Any future call from the now outdated v1 contract should be rejected
+    res = simnet.callPublicFn(
+      pythOracleContractName,
+      `verify-and-update-price-feeds`,
+      [Cl.bufferFromHex("00"), Cl.tuple(executionPlanBase)],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4004));
+  });
+
+  it("should fail if action mismatches", () => {
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-pyth-oracle-contract`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
   });
 });
 
@@ -282,6 +667,10 @@ describe("pyth-governance-v1::update-prices-data-sources", () => {
       chain: 6,
       address: Buffer.alloc(32),
     },
+    {
+      chain: 7,
+      address: Buffer.alloc(32),
+    },
   ];
   let ptgmVaaPayload = pyth.buildPtgmVaaPayload({ updatePricesDataSources });
 
@@ -295,9 +684,12 @@ describe("pyth-governance-v1::update-prices-data-sources", () => {
     );
   });
 
-  it("should update fee-info on successful updates", () => {
+  it("should update prices data sources on successful updates", () => {
     let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
-    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.InitialGovernanceDataSource,
+    });
     let header = wormhole.buildValidVaaHeader(guardianSet, body, {
       version: 1,
       guardianSetId: 1,
@@ -325,4 +717,271 @@ describe("pyth-governance-v1::update-prices-data-sources", () => {
       ),
     );
   });
+
+  it("should fail if action mismatches", () => {
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({ payload });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-prices-data-sources`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
+  });
+});
+
+describe("pyth-governance-v1::update-governance-data-source", () => {
+  const accounts = simnet.getAccounts();
+  const sender = accounts.get("wallet_1")!;
+  const guardianSet = wormhole.generateGuardianSetKeychain(19);
+  let updateGovernanceDataSource = {
+    chain: 0xff,
+    address: hexToBytes(
+      "FF00000000000000000000000000000000000000000000000000000000000000",
+    ),
+  };
+
+  // Before starting the test suite, we have to setup the guardian set.
+  beforeEach(async () => {
+    wormhole.applyGuardianSetUpdate(
+      guardianSet,
+      1,
+      sender,
+      wormholeCoreContractName,
+    );
+
+    pyth.applyGovernanceDataSourceUpdate(
+      pyth.DefaultGovernanceDataSource,
+      pyth.InitialGovernanceDataSource,
+      guardianSet,
+      sender,
+      pythGovernanceContractName,
+      wormholeCoreContractName,
+      1n,
+    );
+  });
+
+  it("should update governance data source on successful updates", () => {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultGovernanceDataSource,
+      sequence: 2n,
+    });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-governance-data-source`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeOk(
+      Cl.tuple({
+        "emitter-address": Cl.buffer(updateGovernanceDataSource.address),
+        "emitter-chain": Cl.uint(updateGovernanceDataSource.chain),
+      }),
+    );
+  });
+
+  it("should fail if action mismatches", () => {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    ptgmVaaPayload.action = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultGovernanceDataSource,
+      sequence: 2n,
+    });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-governance-data-source`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4001));
+  });
+
+  it("should fail if magic bytes are mismatching", () => {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    ptgmVaaPayload.magicBytes = hexToBytes("00000000");
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultGovernanceDataSource,
+      sequence: 2n,
+    });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-prices-data-sources`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4007));
+  });
+
+  it("should fail if target chain id is mismatching", () => {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    ptgmVaaPayload.targetChainId = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultGovernanceDataSource,
+      sequence: 2n,
+    });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-prices-data-sources`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4007));
+  });
+
+  it("should fail if module is mismatching", () => {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    ptgmVaaPayload.module = 0xff;
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultGovernanceDataSource,
+      sequence: 2n,
+    });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-prices-data-sources`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4007));
+  });
+
+  it("should fail if sequence is outdated", () => {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.DefaultGovernanceDataSource,
+      sequence: 1n,
+    });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-governance-data-source`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4005));
+  });
+
+  it("should fail if data source is unauthorized", () => {
+    let ptgmVaaPayload = pyth.buildPtgmVaaPayload({
+      updateGovernanceDataSource,
+    });
+    let payload = pyth.serializePtgmVaaPayloadToBuffer(ptgmVaaPayload);
+    let body = wormhole.buildValidVaaBodySpecs({
+      payload,
+      emitter: pyth.InitialGovernanceDataSource,
+      sequence: 2n,
+    });
+    let header = wormhole.buildValidVaaHeader(guardianSet, body, {
+      version: 1,
+      guardianSetId: 1,
+    });
+    let vaa = wormhole.serializeVaaToBuffer(header, body);
+
+    let wormholeContract = Cl.contractPrincipal(
+      simnet.deployer,
+      wormholeCoreContractName,
+    );
+    let res = simnet.callPublicFn(
+      pythGovernanceContractName,
+      `update-governance-data-source`,
+      [Cl.buffer(vaa), wormholeContract],
+      sender,
+    );
+    expect(res.result).toBeErr(Cl.uint(4006));
+  });
 });
diff --git a/unit-tests/utils/cursor.test.ts b/unit-tests/utils/cursor.test.ts
deleted file mode 100644
index ad83a26..0000000
--- a/unit-tests/utils/cursor.test.ts
+++ /dev/null
@@ -1,669 +0,0 @@
-import { Cl } from "@stacks/transactions";
-import { describe, expect } from "vitest";
-import { it, fc } from "@fast-check/vitest";
-import {
-  concatTypedArrays,
-  uint8toBytes,
-  uint16toBytes,
-  uint32toBytes,
-  bigintToBuffer,
-} from "./helpers";
-
-const cursor_contract_name = "hk-cursor-v1";
-
-describe("hiro-kit::cursor - buffers", () => {
-  const accounts = simnet.getAccounts();
-  const sender = accounts.get("wallet_1")!;
-
-  const buff_n = (n: number) => {
-    return fc.uint8Array({ minLength: 0, maxLength: n });
-  };
-
-  const bytesToRead = () => {
-    return fc.constantFrom(1, 2, 4, 8, 16, 20, 64, 65);
-  };
-
-  const bytesToGenerate = (n: number) => {
-    return fc.uint8Array({ minLength: 0, maxLength: n });
-  };
-
-  it.prop([buff_n(8192)])("new, no offset", (numbers) => {
-    let res = simnet.callReadOnlyFn(
-      cursor_contract_name,
-      `new`,
-      [Cl.buffer(numbers), Cl.none()],
-      sender,
-    );
-    expect(res.result).toBeTuple({
-      value: Cl.none(),
-      next: Cl.tuple({
-        bytes: Cl.buffer(numbers),
-        pos: Cl.uint(0),
-      }),
-    });
-  });
-
-  it.prop([buff_n(8192), fc.nat()])("new, offset", (numbers, offset) => {
-    let res = simnet.callReadOnlyFn(
-      cursor_contract_name,
-      `new`,
-      [Cl.buffer(numbers), Cl.some(Cl.uint(offset))],
-      sender,
-    );
-    expect(res.result).toBeTuple({
-      value: Cl.none(),
-      next: Cl.tuple({
-        bytes: Cl.buffer(numbers),
-        pos: Cl.uint(offset),
-      }),
-    });
-  });
-
-  it.prop([buff_n(8192), fc.nat()])("advance", (numbers, offset) => {
-    let cursor = Cl.tuple({
-      bytes: Cl.buffer(numbers),
-      pos: Cl.uint(0),
-    });
-    let res = simnet.callReadOnlyFn(
-      cursor_contract_name,
-      `advance`,
-      [cursor, Cl.uint(offset)],
-      sender,
-    );
-    expect(res.result).toBeTuple({
-      bytes: Cl.buffer(numbers),
-      pos: Cl.uint(offset),
-    });
-  });
-
-  it.prop([buff_n(8192), fc.nat(2048), fc.nat(2048)])(
-    "slice",
-    (bytes, pos, size) => {
-      let cursor = Cl.tuple({
-        bytes: Cl.buffer(bytes),
-        pos: Cl.uint(pos),
-      });
-
-      if (pos + size < bytes.length) {
-        let res = simnet.callReadOnlyFn(
-          cursor_contract_name,
-          `slice`,
-          [cursor, Cl.some(Cl.uint(size))],
-          sender,
-        );
-        expect(res.result).toBeBuff(bytes.slice(pos, pos + size));
-      }
-    },
-  );
-
-  it.prop([buff_n(8192)])("read-buff-1", (numbers) => {
-    var data = new Uint8Array();
-    for (let n of numbers) {
-      data = concatTypedArrays(data, uint8toBytes(n));
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 1;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-buff-1",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.buffer(uint8toBytes(n)),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  it.prop([fc.uniqueArray(bytesToRead())])("read-buff-n", (buffer) => {
-    var data = new Uint8Array();
-    let segments = [];
-    for (let value of buffer) {
-      var segment = new Uint8Array();
-      for (let i = 0; i < value; i++) {
-        segment = concatTypedArrays(segment, uint8toBytes(value));
-      }
-      segments.push(segment);
-      data = concatTypedArrays(data, segment);
-    }
-
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let segment of segments) {
-      let len = segment.length;
-      pos += len;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        `read-buff-${len}`,
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.buffer(segment),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  it.prop([bytesToRead(), bytesToGenerate(8192)])(
-    "read-buff-8192-max and slice",
-    (toRead, toGenerate) => {
-      var data = new Uint8Array();
-      for (let n of toGenerate) {
-        data = concatTypedArrays(data, uint8toBytes(n));
-      }
-      let input = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(0),
-      });
-
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        `read-buff-${toRead}`,
-        [input],
-        sender,
-      );
-
-      // Early return: we're trying to read more byte than the len of the buffer
-      if (toRead > data.length) {
-        expect(res.result).toBeErr(Cl.uint(1));
-        return;
-      }
-
-      let expectedCursor = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(toRead),
-      });
-
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.buffer(data.subarray(0, toRead)),
-          next: expectedCursor,
-        }),
-      );
-
-      res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        `read-buff-8192-max`,
-        [expectedCursor, Cl.none()],
-        sender,
-      );
-
-      // Early return: we're trying to read more byte than the len of the buffer
-      if (toRead == data.length) {
-        expect(res.result).toBeErr(Cl.uint(1));
-        return;
-      }
-
-      let finalCursor = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(data.length),
-      });
-
-      let expectedBuffer = Cl.buffer(data.subarray(toRead, data.length));
-
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: expectedBuffer,
-          next: finalCursor,
-        }),
-      );
-
-      res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        `slice`,
-        [expectedCursor, Cl.none()],
-        sender,
-      );
-      expect(Cl.ok(res.result)).toBeOk(expectedBuffer);
-    },
-  );
-
-  it.prop([bytesToRead(), bytesToRead(), bytesToGenerate(8192)])(
-    "read-buff-8192-max with limit and slice",
-    (toRead, toIsolate, toGenerate) => {
-      var data = new Uint8Array();
-      for (let n of toGenerate) {
-        data = concatTypedArrays(data, uint8toBytes(n));
-      }
-      let input = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(0),
-      });
-
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        `read-buff-${toRead}`,
-        [input],
-        sender,
-      );
-
-      // Early return: we're trying to read more byte than the len of the buffer
-      if (toRead > data.length) {
-        expect(res.result).toBeErr(Cl.uint(1));
-        return;
-      }
-
-      let expectedCursor = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(toRead),
-      });
-
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.buffer(data.subarray(0, toRead)),
-          next: expectedCursor,
-        }),
-      );
-
-      res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        `read-buff-8192-max`,
-        [expectedCursor, Cl.some(Cl.uint(toIsolate))],
-        sender,
-      );
-
-      // Early return: we're tryint to read more byte than the len of the buffer
-      if (toRead + toIsolate > data.length) {
-        expect(res.result).toBeErr(Cl.uint(1));
-        return;
-      }
-
-      let finalCursor = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(toRead + toIsolate),
-      });
-
-      let expectedBuffer = Cl.buffer(data.subarray(toRead, toRead + toIsolate));
-
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: expectedBuffer,
-          next: finalCursor,
-        }),
-      );
-    },
-  );
-});
-
-describe("hiro-kit::cursor - unsigned integers", () => {
-  const accounts = simnet.getAccounts();
-  const sender = accounts.get("wallet_1")!;
-
-  let arrayOfUint8 = fc.uint8Array({ minLength: 0, maxLength: 8192 });
-  it.prop([arrayOfUint8])("read-uint-8", (numbers) => {
-    var data = new Uint8Array();
-    for (let n of numbers) {
-      data = concatTypedArrays(data, uint8toBytes(n));
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 1;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-uint-8",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.uint(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfUint16 = fc.uint16Array({ minLength: 0, maxLength: 4196 });
-  it.prop([arrayOfUint16])("read-uint-16", (numbers) => {
-    var data = new Uint8Array();
-    for (let n of numbers) {
-      data = concatTypedArrays(data, uint16toBytes(n));
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 2;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-uint-16",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.uint(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfUint32 = fc.uint32Array({ minLength: 0, maxLength: 2048 });
-  it.prop([arrayOfUint32])("read-uint-32", (numbers) => {
-    var data = new Uint8Array();
-
-    for (let n of numbers) {
-      data = concatTypedArrays(data, uint32toBytes(n));
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 4;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-uint-32",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.uint(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfUint64 = fc.array(fc.bigUintN(64), {
-    minLength: 0,
-    maxLength: 1024,
-  });
-  it.prop([arrayOfUint64])("read-uint-64", (numbers) => {
-    var data = Buffer.from([]);
-    for (let n of numbers) {
-      data = Buffer.concat([data, Buffer.from(bigintToBuffer(n, 8))]);
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 8;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-uint-64",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.uint(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfUint128 = fc.array(fc.bigUintN(128), {
-    minLength: 0,
-    maxLength: 512,
-  });
-  it.prop([arrayOfUint128])("read-uint-128", (numbers) => {
-    var data = Buffer.from([]);
-    for (let n of numbers) {
-      data = Buffer.concat([data, Buffer.from(bigintToBuffer(n, 16))]);
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 16;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-uint-128",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.uint(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-});
-
-describe("hiro-kit::cursor - signed integers", () => {
-  const accounts = simnet.getAccounts();
-  const sender = accounts.get("wallet_1")!;
-
-  let arrayOfInt8 = fc.array(fc.bigIntN(8), { minLength: 0, maxLength: 1023 });
-  it.prop([arrayOfInt8])("read-int-8", (numbers) => {
-    var data = Buffer.from([]);
-    for (let n of numbers) {
-      data = Buffer.concat([data, Buffer.from(bigintToBuffer(n, 1))]);
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 1;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-int-8",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.int(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfInt16 = fc.array(fc.bigIntN(16), {
-    minLength: 0,
-    maxLength: 1023,
-  });
-  it.prop([arrayOfInt16])("read-int-16", (numbers) => {
-    var data = Buffer.from([]);
-    for (let n of numbers) {
-      data = Buffer.concat([data, Buffer.from(bigintToBuffer(n, 2))]);
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 2;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-int-16",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.int(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfInt32 = fc.array(fc.bigIntN(32), {
-    minLength: 0,
-    maxLength: 1023,
-  });
-  it.prop([arrayOfInt32])("read-int-32", (numbers) => {
-    var data = Buffer.from([]);
-    for (let n of numbers) {
-      data = Buffer.concat([data, Buffer.from(bigintToBuffer(n, 4))]);
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 4;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-int-32",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.int(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfInt64 = fc.array(fc.bigIntN(64), {
-    minLength: 0,
-    maxLength: 1023,
-  });
-  it.prop([arrayOfInt64])("read-int-64", (numbers) => {
-    var data = Buffer.from([]);
-    for (let n of numbers) {
-      data = Buffer.concat([data, Buffer.from(bigintToBuffer(n, 8))]);
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 8;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-int-64",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.int(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-
-  let arrayOfInt128 = fc.array(fc.bigIntN(128), {
-    minLength: 0,
-    maxLength: 1023,
-  });
-  it.prop([arrayOfInt128])("read-int-128", (numbers) => {
-    var data = Buffer.from([]);
-    for (let n of numbers) {
-      data = Buffer.concat([data, Buffer.from(bigintToBuffer(n, 16))]);
-    }
-    let nextInput = Cl.tuple({
-      bytes: Cl.buffer(data),
-      pos: Cl.uint(0),
-    });
-
-    let pos = 0;
-    for (let n of numbers) {
-      pos += 16;
-      let res = simnet.callReadOnlyFn(
-        cursor_contract_name,
-        "read-int-128",
-        [nextInput],
-        sender,
-      );
-      nextInput = Cl.tuple({
-        bytes: Cl.buffer(data),
-        pos: Cl.uint(pos),
-      });
-      expect(res.result).toBeOk(
-        Cl.tuple({
-          value: Cl.int(n),
-          next: nextInput,
-        }),
-      );
-    }
-  });
-});
diff --git a/unit-tests/utils/helpers.ts b/unit-tests/utils/helpers.ts
index 21562e0..9b09c81 100644
--- a/unit-tests/utils/helpers.ts
+++ b/unit-tests/utils/helpers.ts
@@ -1,28 +1,3 @@
-export function concatTypedArrays(a: any, b: any) {
-  var c = new a.constructor(a.length + b.length);
-  c.set(a, 0);
-  c.set(b, a.length);
-  return c;
-}
-
-export function uint8toBytes(num: number) {
-  let b = new ArrayBuffer(1);
-  new DataView(b).setUint8(0, num);
-  return new Uint8Array(b);
-}
-
-export function uint16toBytes(num: number) {
-  let b = new ArrayBuffer(2);
-  new DataView(b).setUint16(0, num);
-  return new Uint8Array(b);
-}
-
-export function uint32toBytes(num: number) {
-  let b = new ArrayBuffer(4);
-  new DataView(b).setUint32(0, num);
-  return new Uint8Array(b);
-}
-
 export function bigintToBuffer(bigintValue: bigint, byteLength: number) {
   if (bigintValue >= 0n) {
     // Convert BigInt to hexadecimal string
diff --git a/unit-tests/utils/merkle-proofs.test.ts b/unit-tests/utils/merkle-proofs.test.ts
deleted file mode 100644
index 96d3cb5..0000000
--- a/unit-tests/utils/merkle-proofs.test.ts
+++ /dev/null
@@ -1,197 +0,0 @@
-import { Cl } from "@stacks/transactions";
-import { describe, expect, it } from "vitest";
-
-const merkle_contract_name = "hk-merkle-tree-keccak160-v1";
-
-// The test vectors executed in the following test suite are coming from:
-// https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/aptos/contracts/sources/merkle.move
-
-describe("hiro-kit::hk-merkle-tree-keccak160", () => {
-  const accounts = simnet.getAccounts();
-  const sender = accounts.get("wallet_1")!;
-
-  const setupTree = () => {
-    //
-    //   h1  h2  h3   h4
-    //    \ /     \  /
-    //     h5      h6
-    //        \  /
-    //         h7
-    //
-    let h1 = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-leaf",
-      [Cl.bufferFromHex("adad11")],
-      sender,
-    ).result;
-    let h2 = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-leaf",
-      [Cl.bufferFromHex("adad12")],
-      sender,
-    ).result;
-    let h3 = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-leaf",
-      [Cl.bufferFromHex("adad13")],
-      sender,
-    ).result;
-    let h4 = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-leaf",
-      [Cl.bufferFromHex("adad14")],
-      sender,
-    ).result;
-    let h5 = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-nodes",
-      [h1, h2],
-      sender,
-    ).result;
-    let h6 = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-nodes",
-      [h3, h4],
-      sender,
-    ).result;
-    let h7 = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-nodes",
-      [h5, h6],
-      sender,
-    ).result;
-    return [h1, h2, h3, h4, h5, h6, h7];
-  };
-
-  it("hash leaf", () => {
-    let res = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-leaf",
-      [
-        Cl.bufferFromHex(
-          "00640000000000000000000000000000000000000000000000000000000000000000000000000000640000000000000064000000640000000000000064000000000000006400000000000000640000000000000064",
-        ),
-      ],
-      sender,
-    );
-    expect(res.result).toStrictEqual(
-      Cl.bufferFromHex("afc6a8ac466430f35895055f8a4c951785dad5ce"),
-    );
-  });
-
-  it("hash node", () => {
-    let h1 = Cl.bufferFromHex("05c51b04b820c0f704e3fdd2e4fc1e70aff26dff");
-    let h2 = Cl.bufferFromHex("1e108841c8d21c7a5c4860c8c3499c918ea9e0ac");
-    let res = simnet.callReadOnlyFn(
-      merkle_contract_name,
-      "hash-nodes",
-      [h1, h2],
-      sender,
-    );
-    expect(res.result).toStrictEqual(
-      Cl.bufferFromHex("2d0e4fde68184c7ce8af426a0865bd41ef84dfa4"),
-    );
-  });
-
-  it("check valid proofs", () => {
-    let [h1, h2, h3, h4, h5, h6, h7] = setupTree();
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h7, Cl.bufferFromHex("adad11"), Cl.list([h2, h6])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(true));
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h7, Cl.bufferFromHex("adad14"), Cl.list([h3, h5])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(true));
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h7, Cl.bufferFromHex("adad14"), Cl.list([h1, h4])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(false));
-  });
-
-  it("check valid proofs subtree", () => {
-    let [h1, h2, h3, h4, h5, h6, _] = setupTree();
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h5, Cl.bufferFromHex("adad12"), Cl.list([h1])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(true));
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h5, Cl.bufferFromHex("adad11"), Cl.list([h2])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(true));
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h6, Cl.bufferFromHex("adad14"), Cl.list([h3])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(true));
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h6, Cl.bufferFromHex("adad13"), Cl.list([h4])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(true));
-  });
-
-  it("check invalid proofs", () => {
-    let [h1, h2, h3, h4, h5, h6, h7] = setupTree();
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h7, Cl.bufferFromHex("dead"), Cl.list([h2, h6])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(false));
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h7, Cl.bufferFromHex("dead"), Cl.list([h3, h5])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(false));
-
-    expect(
-      simnet.callReadOnlyFn(
-        merkle_contract_name,
-        "check-proof",
-        [h7, Cl.bufferFromHex("dead"), Cl.list([h1, h4])],
-        sender,
-      ).result,
-    ).toStrictEqual(Cl.bool(false));
-  });
-});
diff --git a/unit-tests/wormhole/governance.test.ts b/unit-tests/wormhole/governance.test.ts
deleted file mode 100644
index da817f1..0000000
--- a/unit-tests/wormhole/governance.test.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { expect, describe } from "vitest";
-import { it, fc } from '@fast-check/vitest';
-
-it("pending", () => {
-
-    
-})
\ No newline at end of file
diff --git a/unit-tests/wormhole/helpers.ts b/unit-tests/wormhole/helpers.ts
index 4bf2d4b..64598a0 100644
--- a/unit-tests/wormhole/helpers.ts
+++ b/unit-tests/wormhole/helpers.ts
@@ -11,6 +11,7 @@ if (!globalThis.crypto) globalThis.crypto = webcrypto;
 import { hmac } from "@noble/hashes/hmac";
 import { sha256 } from "@noble/hashes/sha256";
 import { gsuMainnetVaas } from "./fixtures";
+import { pyth } from "../pyth/helpers";
 
 secp.etc.hmacSha256Sync = (k, ...m) =>
   hmac(sha256, k, secp.etc.concatBytes(...m));
@@ -43,6 +44,11 @@ export namespace wormhole {
     return keychain;
   };
 
+  export interface Emitter {
+    chain: number;
+    address: Uint8Array;
+  }
+
   export interface VaaHeader {
     version: number;
     guardianSetId: number;
@@ -298,17 +304,21 @@ export namespace wormhole {
 
   export const buildValidVaaBodySpecs = (opts?: {
     payload?: Uint8Array;
+    emitter?: Emitter;
+    sequence?: bigint;
   }): VaaBody => {
     const date = Math.floor(Date.now() / 1000);
     const timestamp = date >>> 0;
     const payload =
       (opts && opts.payload && opts.payload) || new Uint8Array(32);
+    let emitter =
+      opts && opts.emitter ? opts.emitter : pyth.InitialGovernanceDataSource;
     let values = {
       timestamp: timestamp,
       nonce: 0,
-      emitterChain: 0,
-      emitterAddress: new Uint8Array(32),
-      sequence: 0n,
+      emitterChain: emitter.chain,
+      emitterAddress: emitter.address,
+      sequence: opts && opts.sequence ? opts.sequence : 1n,
       consistencyLevel: 0,
       payload: payload,
     };
@@ -444,7 +454,7 @@ export namespace wormhole {
     keychain: wormhole.Guardian[],
     guardianSetId: number,
     txSenderAddress: string,
-    contract_name: string,
+    contractName: string,
   ) {
     let guardianRotationPayload =
       wormhole.serializeGuardianUpdateVaaPayloadToBuffer(
@@ -468,7 +478,7 @@ export namespace wormhole {
     }
     let result = simnet.mineBlock([
       tx.callPublicFn(
-        contract_name,
+        contractName,
         `update-guardians-set`,
         [Cl.buffer(vaa), Cl.list(uncompressedPublicKey)],
         txSenderAddress,
diff --git a/unit-tests/wormhole/vaa.test.ts b/unit-tests/wormhole/vaa.test.ts
index 75da0cc..dfb2c0e 100644
--- a/unit-tests/wormhole/vaa.test.ts
+++ b/unit-tests/wormhole/vaa.test.ts
@@ -244,7 +244,7 @@ describe("wormhole-core-v1::update-guardians-set success", () => {
   });
 
   it("should return the set 1 as active", () => {
-    let res = simnet.callPublicFn(
+    let res = simnet.callReadOnlyFn(
       contractName,
       `get-active-guardian-set`,
       [],
@@ -313,7 +313,7 @@ describe("wormhole-core-v1::update-guardians-set success", () => {
       }),
     );
 
-    res = simnet.callPublicFn(
+    res = simnet.callReadOnlyFn(
       contractName,
       `get-active-guardian-set`,
       [],