Aptos integration

.github/workflows/ci.yml

@@ -24,15 +24,25 @@ jobs:
           go-version: '1.22'
 
       - name: Cache Go modules
+        id: go-cache
         uses: actions/cache@v3
         with:
           path: |
             ~/.cache/go-build
             ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
+            ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
             ${{ runner.os }}-go-
 
+      - name: Clean Go module cache if needed
+        run: |
+          if ! go mod download 2>/dev/null; then
+            echo "Module download failed, cleaning cache..."
+            go clean -modcache
+            go mod download
+          fi
+
       - name: Cache Rust dependencies
         uses: actions/cache@v3
         with:
@@ -200,3 +210,42 @@ jobs:
         run: |
           sui move test
         working-directory: ./contracts/sui/contracts
+
+  test-aptos:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+          cache: 'pip'
+          cache-dependency-path: '**/requirements.txt'
+
+      - name: Install pip dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install packaging
+
+      - name: Cache Aptos CLI
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.aptos
+            ~/.local/bin/aptos
+          key: ${{ runner.os }}-aptos-cli
+
+      - name: Install Aptos CLI
+        run: |
+          if ! command -v aptos &> /dev/null; then
+            curl -fsSL "https://aptos.dev/scripts/install_cli.py" | python3
+          fi
+          aptos --version
+
+      - name: Run Aptos tests
+        run: |
+          aptos move test --move-2 --dev
+        working-directory: ./contracts/aptos/contracts

apps/cmd/chain_pusher/main.go

@@ -42,6 +42,7 @@ func main() {
 	rootCmd.AddCommand(chain_pusher.EvmpushCmd)
 	rootCmd.AddCommand(chain_pusher.SolanapushCmd)
 	rootCmd.AddCommand(chain_pusher.SuipushCmd)
+	rootCmd.AddCommand(chain_pusher.AptospushCmd)
 
 	if err := rootCmd.Execute(); err != nil {
 		log.Fatal(err)

apps/docs/chain_pusher.md

@@ -113,6 +113,29 @@ go run ./cmd/chain_pusher/main.go sui \
 
 ### Sui Development Setup
 At the time of writing there is no way to generate Go bindings for Sui automatically. Manually built contract bindings/utilities can be found [here](../lib/chain_pusher/contract_bindings/sui/stork_sui_contract.go).
+
+## Aptos Chain Setup
+
+### Wallet Setup
+Create a `.key` file containing your Aptos wallet private key. This file is needed to sign transactions.
+
+### Running the Aptos Pusher
+For full explanation of the flags, run:
+```bash
+go run . aptos --help
+```
+
+Basic usage:
+```bash
+go run ./cmd/chain_pusher/main.go aptos \
+    -w wss://api.jp.stork-oracle.network \
+    -a <stork-api-key> \
+    -c <chain-rpc-url> \
+    -x <contract-address> \
+    -f <asset-config-file> \
+    -k <key-file>
+```
+
 ## Deployment
 
 ### Running on EC2

apps/lib/chain_pusher/aptos-push.go

@@ -0,0 +1,50 @@
+package chain_pusher
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var AptospushCmd = &cobra.Command{
+	Use:   "aptos",
+	Short: "Push WebSocket prices to Aptos contract",
+	Run:   runAptosPush,
+}
+
+func init() {
+	AptospushCmd.Flags().StringP(StorkWebsocketEndpointFlag, "w", "", StorkWebsocketEndpointDesc)
+	AptospushCmd.Flags().StringP(StorkAuthCredentialsFlag, "a", "", StorkAuthCredentialsDesc)
+	AptospushCmd.Flags().StringP(ChainRpcUrlFlag, "c", "", ChainRpcUrlDesc)
+	AptospushCmd.Flags().StringP(ContractAddressFlag, "x", "", ContractAddressDesc)
+	AptospushCmd.Flags().StringP(AssetConfigFileFlag, "f", "", AssetConfigFileDesc)
+	AptospushCmd.Flags().StringP(PrivateKeyFileFlag, "k", "", PrivateKeyFileDesc)
+	AptospushCmd.Flags().IntP(BatchingWindowFlag, "b", 5, BatchingWindowDesc)
+	AptospushCmd.Flags().IntP(PollingFrequencyFlag, "p", 3, PollingFrequencyDesc)
+
+	AptospushCmd.MarkFlagRequired(StorkWebsocketEndpointFlag)
+	AptospushCmd.MarkFlagRequired(StorkAuthCredentialsFlag)
+	AptospushCmd.MarkFlagRequired(ChainRpcUrlFlag)
+	AptospushCmd.MarkFlagRequired(ContractAddressFlag)
+	AptospushCmd.MarkFlagRequired(AssetConfigFileFlag)
+	AptospushCmd.MarkFlagRequired(PrivateKeyFileFlag)
+}
+
+func runAptosPush(cmd *cobra.Command, args []string) {
+	storkWsEndpoint, _ := cmd.Flags().GetString(StorkWebsocketEndpointFlag)
+	storkAuth, _ := cmd.Flags().GetString(StorkAuthCredentialsFlag)
+	chainRpcUrl, _ := cmd.Flags().GetString(ChainRpcUrlFlag)
+	contractAddress, _ := cmd.Flags().GetString(ContractAddressFlag)
+	assetConfigFile, _ := cmd.Flags().GetString(AssetConfigFileFlag)
+	privateKeyFile, _ := cmd.Flags().GetString(PrivateKeyFileFlag)
+	batchingWindow, _ := cmd.Flags().GetInt(BatchingWindowFlag)
+	pollingFrequency, _ := cmd.Flags().GetInt(PollingFrequencyFlag)
+
+	logger := AptosPusherLogger(chainRpcUrl, contractAddress)
+
+	aptosInteracter, err := NewAptosContractInteracter(chainRpcUrl, contractAddress, privateKeyFile, assetConfigFile, pollingFrequency, logger)
+	if err != nil {
+		logger.Fatal().Err(err).Msg("Failed to initialize Aptos contract interacter")
+	}
+
+	aptosPusher := NewPusher(storkWsEndpoint, storkAuth, chainRpcUrl, contractAddress, assetConfigFile, batchingWindow, pollingFrequency, aptosInteracter, &logger)
+	aptosPusher.Run()
+}

apps/lib/chain_pusher/aptos.go

@@ -0,0 +1,156 @@
+package chain_pusher
+
+import (
+	"fmt"
+	"math/big"
+	"os"
+	"strings"
+
+	contract "github.com/Stork-Oracle/stork-external/apps/lib/chain_pusher/contract_bindings/aptos"
+	"github.com/rs/zerolog"
+)
+
+type AptosContractInteracter struct {
+	logger   zerolog.Logger
+	contract *contract.StorkContract
+
+	pollingFrequencySec int
+}
+
+func NewAptosContractInteracter(rpcUrl, contractAddr, privateKeyFile string, assetConfigFile string, pollingFreqSec int, logger zerolog.Logger) (*AptosContractInteracter, error) {
+	logger = logger.With().Str("component", "aptos-contract-interactor").Logger()
+
+	keyFileContent, err := os.ReadFile(privateKeyFile)
+	if err != nil {
+		return nil, err
+	}
+
+	privateKey := strings.TrimSpace(strings.Split(string(keyFileContent), "\n")[0])
+
+	contract, err := contract.NewStorkContract(rpcUrl, contractAddr, privateKey)
+	if err != nil {
+		return nil, err
+	}
+
+	return &AptosContractInteracter{
+		logger:              logger,
+		contract:            contract,
+		pollingFrequencySec: pollingFreqSec,
+	}, nil
+}
+
+// unfortunately, Aptos doesn't currently support websocket RPCs, so we can't listen to events from the contract
+// the contract does emit events, so this can be implemented in the future if Aptos re-adds websocket support
+func (aci *AptosContractInteracter) ListenContractEvents(ch chan map[InternalEncodedAssetId]InternalStorkStructsTemporalNumericValue) {
+	aci.logger.Warn().Msg("Aptos does not currently support listening to events via websocket, falling back to polling")
+}
+
+func (aci *AptosContractInteracter) PullValues(encodedAssetIds []InternalEncodedAssetId) (map[InternalEncodedAssetId]InternalStorkStructsTemporalNumericValue, error) {
+	// convert to bindings EncodedAssetId
+	bindingsEncodedAssetIds := []contract.EncodedAssetId{}
+	for _, encodedAssetId := range encodedAssetIds {
+		bindingsEncodedAssetIds = append(bindingsEncodedAssetIds, contract.EncodedAssetId(encodedAssetId))
+	}
+	values, err := aci.contract.GetMultipleTemporalNumericValuesUnchecked(bindingsEncodedAssetIds)
+	aci.logger.Debug().Msgf("successfully pulled %d values from contract", len(values))
+	if err != nil {
+		return nil, err
+	}
+
+	// convert to map[InternalEncodedAssetId]InternalStorkStructsTemporalNumericValue
+	result := make(map[InternalEncodedAssetId]InternalStorkStructsTemporalNumericValue)
+	for _, encodedAssetId := range encodedAssetIds {
+		if value, ok := values[contract.EncodedAssetId(encodedAssetId)]; ok {
+
+			magnitude := value.QuantizedValue.Magnitude
+			negative := value.QuantizedValue.Negative
+			signMultiplier := 1
+			if negative {
+				signMultiplier = -1
+			}
+			quantizedValue := new(big.Int).Mul(magnitude, big.NewInt(int64(signMultiplier)))
+
+			result[encodedAssetId] = InternalStorkStructsTemporalNumericValue{
+				TimestampNs:    value.TimestampNs,
+				QuantizedValue: quantizedValue,
+			}
+		}
+	}
+	return result, nil
+}
+
+func (aci *AptosContractInteracter) BatchPushToContract(priceUpdates map[InternalEncodedAssetId]AggregatedSignedPrice) error {
+
+	var updateData []contract.UpdateData
+	for _, price := range priceUpdates {
+		update, err := aci.aggregatedSignedPriceToAptosUpdateData(price)
+		if err != nil {
+			return err
+		}
+		updateData = append(updateData, update)
+	}
+	hash, err := aci.contract.UpdateMultipleTemporalNumericValuesEvm(updateData)
+	if err != nil {
+		aci.logger.Error().Err(err).Msg("failed to update multiple temporal numeric values")
+		return err
+	}
+	aci.logger.Info().
+		Int("numUpdates", len(priceUpdates)).
+		Str("txnHash", hash).
+		Msg("Successfully pushed batch update to contract")
+	return nil
+}
+
+func (aci *AptosContractInteracter) aggregatedSignedPriceToAptosUpdateData(price AggregatedSignedPrice) (contract.UpdateData, error) {
+	signedPrice := price.StorkSignedPrice
+	assetId, err := hexStringToByteArray(string(signedPrice.EncodedAssetId))
+	if err != nil {
+		return contract.UpdateData{}, fmt.Errorf("failed to convert encoded asset id to byte array: %w", err)
+	}
+	timestampNs := uint64(signedPrice.TimestampedSignature.Timestamp)
+	magnitude_string := string(signedPrice.QuantizedPrice)
+	magnitude, ok := new(big.Int).SetString(magnitude_string, 10)
+	if !ok {
+		return contract.UpdateData{}, fmt.Errorf("failed to convert quantized price to big int")
+	}
+	negative := magnitude.Sign() == -1
+	magnitude.Abs(magnitude)
+
+	publisherMerkleRoot, err := hexStringToByteArray(signedPrice.PublisherMerkleRoot)
+	if err != nil {
+		return contract.UpdateData{}, fmt.Errorf("failed to convert publisher merkle root to byte array: %w", err)
+	}
+
+	valueComputeAlgHash, err := hexStringToByteArray(signedPrice.StorkCalculationAlg.Checksum)
+	if err != nil {
+		return contract.UpdateData{}, fmt.Errorf("failed to convert value compute alg hash to byte array: %w", err)
+	}
+
+	r, err := hexStringToByteArray(signedPrice.TimestampedSignature.Signature.R)
+	if err != nil {
+		return contract.UpdateData{}, fmt.Errorf("failed to convert R to byte array: %w", err)
+	}
+
+	s, err := hexStringToByteArray(signedPrice.TimestampedSignature.Signature.S)
+	if err != nil {
+		return contract.UpdateData{}, fmt.Errorf("failed to convert S to byte array: %w", err)
+	}
+
+	vBytes, err := hexStringToByteArray(signedPrice.TimestampedSignature.Signature.V)
+	if err != nil {
+		return contract.UpdateData{}, fmt.Errorf("failed to convert V to byte array: %w", err)
+	}
+	v := byte(vBytes[0])
+
+	return contract.UpdateData{
+		Id:                              assetId,
+		TemporalNumericValueTimestampNs: timestampNs,
+		TemporalNumericValueMagnitude:   magnitude,
+		TemporalNumericValueNegative:    negative,
+		PublisherMerkleRoot:             publisherMerkleRoot,
+		ValueComputeAlgHash:             valueComputeAlgHash,
+		R:                               r,
+		S:                               s,
+		V:                               v,
+	}, nil
+}

apps/lib/chain_pusher/contract_bindings/aptos/stork_aptos_contract.go

@@ -0,0 +1,254 @@
+// Unlike the EVM and Solana bindings, the Aptos bindings are generated from the Move source code, as a tool for this does currently exist.
+// Instead, this file contains utility functions for interacting with the Aptos Stork contract.
+// These functions are written using the official aptos go sdk.
+
+package contract_bindings_aptos
+
+import (
+	"fmt"
+	"math/big"
+	"strconv"
+	"sync"
+
+	"github.com/aptos-labs/aptos-go-sdk"
+	"github.com/aptos-labs/aptos-go-sdk/bcs"
+	"github.com/aptos-labs/aptos-go-sdk/crypto"
+)
+
+type StorkContract struct {
+	Client          *aptos.Client
+	Account         *aptos.Account
+	ContractAddress aptos.AccountAddress
+}
+
+type EncodedAssetId [32]byte
+
+type TemporalNumericValue struct {
+	TimestampNs    uint64
+	QuantizedValue I128
+}
+
+type I128 struct {
+	Magnitude *big.Int
+	Negative  bool
+}
+
+type UpdateData struct {
+	Id                              []byte
+	TemporalNumericValueTimestampNs uint64
+	TemporalNumericValueMagnitude   *big.Int
+	TemporalNumericValueNegative    bool
+	PublisherMerkleRoot             []byte
+	ValueComputeAlgHash             []byte
+	R                               []byte
+	S                               []byte
+	V                               byte
+}
+
+func NewStorkContract(rpcUrl string, contractAddress string, key string) (*StorkContract, error) {
+	config := aptos.NetworkConfig{
+		Name:       "",
+		ChainId:    0,
+		NodeUrl:    rpcUrl,
+		FaucetUrl:  "",
+		IndexerUrl: "",
+	}
+	client, err := aptos.NewClient(config)
+	if err != nil {
+		return nil, err
+	}
+
+	formattedPrivateKey, err := crypto.FormatPrivateKey(key, crypto.PrivateKeyVariantEd25519)
+	if err != nil {
+		return nil, err
+	}
+
+	privateKey := &crypto.Ed25519PrivateKey{}
+	err = privateKey.FromHex(formattedPrivateKey)
+
+	if err != nil {
+		return nil, err
+	}
+
+	account, err := aptos.NewAccountFromSigner(privateKey)
+	if err != nil {
+		return nil, err
+	}
+
+	address := aptos.AccountAddress{}
+	err = address.ParseStringRelaxed(contractAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	return &StorkContract{Client: client, Account: account, ContractAddress: address}, nil
+}
+
+func (sc *StorkContract) getTemporalNumericValueUnchecked(id EncodedAssetId) (TemporalNumericValue, error) {
+	serializer := bcs.Serializer{}
+	serializer.WriteBytes(id[:])
+	encodedAssetId := serializer.ToBytes()
+
+	payload := &aptos.ViewPayload{
+		Module: aptos.ModuleId{
+			Address: sc.ContractAddress,
+			Name:    "stork",
+		},
+		Function: "get_temporal_numeric_value_unchecked",
+		ArgTypes: []aptos.TypeTag{},
+		Args:     [][]byte{encodedAssetId},
+	}
+
+	value, err := sc.Client.View(payload)
+	if err != nil {
+		return TemporalNumericValue{}, err
+	}
+
+	if len(value) == 0 {
+		return TemporalNumericValue{}, fmt.Errorf("empty response")
+	}
+
+	responseMap := value[0].(map[string]interface{})
+	timestamp, err := strconv.ParseUint(responseMap["timestamp_ns"].(string), 10, 64)
+	if err != nil {
+		return TemporalNumericValue{}, fmt.Errorf("failed to parse timestamp: %w", err)
+	}
+
+	quantizedValue := responseMap["quantized_value"].(map[string]interface{})
+	magnitude := new(big.Int)
+	magnitude.SetString(quantizedValue["magnitude"].(string), 10)
+	negative := quantizedValue["negative"].(bool)
+
+	return TemporalNumericValue{
+		TimestampNs: timestamp,
+		QuantizedValue: I128{
+			Magnitude: magnitude,
+			Negative:  negative,
+		},
+	}, nil
+}
+
+// GetMultipleTemporalNumericValuesUnchecked returns the temporal numeric values for the given feed IDs.
+func (sc *StorkContract) GetMultipleTemporalNumericValuesUnchecked(feedIds []EncodedAssetId) (map[EncodedAssetId]TemporalNumericValue, error) {
+	response := map[EncodedAssetId]TemporalNumericValue{}
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+
+	for _, id := range feedIds {
+		wg.Add(1)
+		go func(id EncodedAssetId) {
+			defer wg.Done()
+
+			value, err := sc.getTemporalNumericValueUnchecked(id)
+			if err != nil {
+				// unfortunately, errors from view functions are pretty bad, so we assume an error means the value is not available
+				return
+			}
+
+			mu.Lock()
+			response[id] = value
+			mu.Unlock()
+		}(id)
+	}
+
+	wg.Wait()
+
+	return response, nil
+}
+
+func (sc *StorkContract) UpdateMultipleTemporalNumericValuesEvm(updateData []UpdateData) (string, error) {
+	// Create separate serializers for each vector
+	idsSerializer := bcs.Serializer{}
+	timestampsSerializer := bcs.Serializer{}
+	magnitudesSerializer := bcs.Serializer{}
+	negativesSerializer := bcs.Serializer{}
+	merkleRootsSerializer := bcs.Serializer{}
+	algHashesSerializer := bcs.Serializer{}
+	rsSerializer := bcs.Serializer{}
+	ssSerializer := bcs.Serializer{}
+	vsSerializer := bcs.Serializer{}
+
+	// Serialize each vector with its own serializer
+	idsSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		idsSerializer.WriteBytes(data.Id)
+	}
+
+	timestampsSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		timestampsSerializer.U64(data.TemporalNumericValueTimestampNs)
+	}
+
+	magnitudesSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		magnitudesSerializer.U128(*data.TemporalNumericValueMagnitude)
+	}
+
+	negativesSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		negativesSerializer.Bool(data.TemporalNumericValueNegative)
+	}
+
+	merkleRootsSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		merkleRootsSerializer.WriteBytes(data.PublisherMerkleRoot)
+	}
+
+	algHashesSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		algHashesSerializer.WriteBytes(data.ValueComputeAlgHash)
+	}
+
+	rsSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		rsSerializer.WriteBytes(data.R)
+	}
+
+	ssSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		ssSerializer.WriteBytes(data.S)
+	}
+
+	vsSerializer.Uleb128(uint32(len(updateData)))
+	for _, data := range updateData {
+		vsSerializer.U8(data.V)
+	}
+
+	// Create the transaction payload with all serialized vectors
+	payload := &aptos.EntryFunction{
+		Module: aptos.ModuleId{
+			Address: sc.ContractAddress,
+			Name:    "stork",
+		},
+		Function: "update_multiple_temporal_numeric_values_evm",
+		ArgTypes: []aptos.TypeTag{},
+		Args: [][]byte{
+			idsSerializer.ToBytes(),
+			timestampsSerializer.ToBytes(),
+			magnitudesSerializer.ToBytes(),
+			negativesSerializer.ToBytes(),
+			merkleRootsSerializer.ToBytes(),
+			algHashesSerializer.ToBytes(),
+			rsSerializer.ToBytes(),
+			ssSerializer.ToBytes(),
+			vsSerializer.ToBytes(),
+		},
+	}
+
+	submitResponse, err := sc.Client.BuildSignAndSubmitTransaction(sc.Account, aptos.TransactionPayload{Payload: payload})
+	if err != nil {
+		return "", err
+	}
+
+	hash := submitResponse.Hash
+	tx, err := sc.Client.WaitForTransaction(hash)
+	if err != nil {
+		return "", err
+	}
+
+	if !tx.Success {
+		return "", fmt.Errorf("transaction failed: %s", tx.VmStatus)
+	}
+
+	return tx.Hash, nil
+}

apps/lib/chain_pusher/log.go

@@ -47,3 +47,13 @@ func SuiPusherLogger(
 		Str("contractAddress", contractAddress).
 		Logger()
 }
+
+func AptosPusherLogger(
+	chainRpcUrl string,
+	contractAddress string,
+) zerolog.Logger {
+	return AppLogger("aptos").With().
+		Str("chainRpcUrl", chainRpcUrl).
+		Str("contractAddress", contractAddress).
+		Logger()
+}

contracts/aptos/README.md

@@ -0,0 +1,38 @@
+# Stork Aptos Contract
+
+This directory contains an [Aptos Move](https://aptos.dev/move) the Stork Aptos compatible contract.
+
+This contract is used to read and write the latest values from the Stork network on-chain.
+
+### Getting started
+
+```bash
+aptos init
+aptos move test --move-2 --dev
+```
+
+### Local Development
+
+#### Run local node
+
+```bash
+aptos node run-local-testnet --with-indexer-api
+```
+
+#### Test
+
+```bash
+aptos move test --move-2 --dev
+```
+
+#### Deploy
+
+```bash
+aptos move deploy-object --address-name stork --profile <profile> --move-2
+```
+
+#### Upgrade
+
+```bash
+aptos move upgrade-object --address-name stork --profile <profile> --object-address <object-address> --move-2
+```

contracts/aptos/cli/.gitignore

@@ -0,0 +1 @@
+node_modules/

contracts/aptos/cli/admin.ts

@@ -0,0 +1,299 @@
+import { Command } from "commander";
+import { Account, Aptos, AptosConfig, Network, Ed25519PrivateKey, PrivateKey, PrivateKeyVariants} from "@aptos-labs/ts-sdk";
+
+const DEFAULT_CONTRACT_ADDRESS = process.env.STORK_CONTRACT_ADDRESS;
+const DEFAULT_STORK_EVM_PUBLIC_KEY = "0x0a803F9b1CCe32e2773e0d2e98b37E0775cA5d44";
+const DEFAULT_UPDATE_FEE_IN_OCTAS = 1;
+const PRIVATE_KEY: string | undefined = process.env.PRIVATE_KEY;
+
+const APTOS_CONFIG = new AptosConfig({
+    network: process.env.RPC_ALIAS as Network,
+});
+
+const aptos = new Aptos(APTOS_CONFIG);
+
+type UpdateData = {
+    ids: number[][];
+    temporal_numeric_value_timestamp_nss: bigint[];
+    temporal_numeric_value_magnitudes: bigint[];
+    temporal_numeric_value_negatives: boolean[];
+    publisher_merkle_roots: number[][];
+    value_compute_alg_hashes: number[][];
+    rs: number[][];
+    ss: number[][];
+    vs: number[];
+}
+
+function getAccount() {
+    if (!PRIVATE_KEY) {
+        throw new Error("PRIVATE_KEY is not set");
+    }
+
+    const formattedKey = PrivateKey.formatPrivateKey(PRIVATE_KEY, PrivateKeyVariants.Ed25519);
+    const privateKey = new Ed25519PrivateKey(formattedKey);
+    const account = Account.fromPrivateKey({ privateKey, legacy: true });
+    return account;
+}
+
+function hexStringToByteArray(hexString: string) {
+    if (hexString.startsWith("0x")) {
+      hexString = hexString.slice(2);
+    }
+    return Array.from(Buffer.from(hexString, "hex"));
+}
+
+const cliProgram = new Command();
+cliProgram
+    .name("admin")
+    .description("Aptos Stork admin client")
+    .version("0.1.0");
+
+cliProgram
+    .command("initialize")
+    .description("Initialize the Stork contract")
+    .action(async () => {
+        const account = getAccount();
+        const contractAddress = DEFAULT_CONTRACT_ADDRESS;
+        const tx = await aptos.transaction.build.simple({
+            sender: account.accountAddress,
+            data: {
+                function: `${contractAddress}::stork::init_stork`,
+                functionArguments: [
+                    hexStringToByteArray(DEFAULT_STORK_EVM_PUBLIC_KEY),
+                    DEFAULT_UPDATE_FEE_IN_OCTAS,
+                ],
+            },
+        });
+        const senderAuthenticator = aptos.transaction.sign({
+            signer: account,
+            transaction: tx,
+        });
+
+        const committedTransaction = await aptos.transaction.submit.simple({
+            transaction: tx,
+            senderAuthenticator,
+        });
+
+        const executedTransaction = await aptos.waitForTransaction({ transactionHash: committedTransaction.hash });
+        if (executedTransaction.success) {
+            console.log(`Transaction succeeded: ${committedTransaction.hash}`);
+        } else {
+            console.error(`Transaction failed: ${committedTransaction.hash}`);
+        }
+    });
+
+cliProgram
+    .command("write-to-feeds")
+    .description("Write to feeds")
+    .argument("asset_pairs", "Comma separated list of asset pairs to write to")
+    .argument("endpoint", "The stork REST endpoint")
+    .argument("auth_key", "The stork auth key")
+    .action(async (assetPairs: string, endpoint: string, authKey: string) => {
+        const account = getAccount();
+        const contractAddress = DEFAULT_CONTRACT_ADDRESS;
+
+        const result = await fetch(`${endpoint}/v1/prices/latest\?assets=${assetPairs}`, 
+            {
+            headers: {
+                "Authorization": `Basic ${authKey}`,
+            },
+        });
+
+
+        const rawJson = await result.text();
+        const safeJsonText = rawJson.replace(
+            /(?<!["\d])\b\d{16,}\b(?!["])/g, // Regex to find large integers not already in quotes
+            (match) => `"${match}"` // Convert large numbers to strings
+            ); 
+
+        const response = JSON.parse(safeJsonText);
+        const updateData: UpdateData = {
+            ids: [],
+            temporal_numeric_value_timestamp_nss: [],
+            temporal_numeric_value_magnitudes: [],
+            temporal_numeric_value_negatives: [],
+            publisher_merkle_roots: [],
+            value_compute_alg_hashes: [],
+            rs: [],
+            ss: [],
+            vs: [],
+        }
+
+        Object.values(response.data).forEach((data: any) => {
+            updateData.ids.push(hexStringToByteArray(data.stork_signed_price.encoded_asset_id));
+            updateData.temporal_numeric_value_timestamp_nss.push(BigInt(data.stork_signed_price.timestamped_signature.timestamp));
+            updateData.temporal_numeric_value_magnitudes.push(BigInt(data.stork_signed_price.price));
+            updateData.temporal_numeric_value_negatives.push(data.stork_signed_price.price < 0);
+            updateData.publisher_merkle_roots.push(hexStringToByteArray(data.stork_signed_price.publisher_merkle_root));
+            updateData.value_compute_alg_hashes.push(hexStringToByteArray(data.stork_signed_price.calculation_alg.checksum));
+            updateData.rs.push(hexStringToByteArray(data.stork_signed_price.timestamped_signature.signature.r));
+            updateData.ss.push(hexStringToByteArray(data.stork_signed_price.timestamped_signature.signature.s));
+            updateData.vs.push(hexStringToByteArray(data.stork_signed_price.timestamped_signature.signature.v)[0]);
+        });
+
+        const tx = await aptos.transaction.build.simple({
+            sender: account.accountAddress,
+            data: {
+                function: `${contractAddress}::stork::update_multiple_temporal_numeric_values_evm`,
+                functionArguments: [
+                    updateData.ids,
+                    updateData.temporal_numeric_value_timestamp_nss,
+                    updateData.temporal_numeric_value_magnitudes,
+                    updateData.temporal_numeric_value_negatives,
+                    updateData.publisher_merkle_roots,
+                    updateData.value_compute_alg_hashes,
+                    updateData.rs,
+                    updateData.ss,
+                    updateData.vs,
+                ],
+            },
+        });
+
+        const senderAuthenticator = aptos.transaction.sign({
+            signer: account,
+            transaction: tx,
+        });
+
+        const committedTransaction = await aptos.transaction.submit.simple({
+            transaction: tx,
+            senderAuthenticator,
+        });
+
+        const executedTransaction = await aptos.waitForTransaction({ transactionHash: committedTransaction.hash });
+        if (executedTransaction.success) {
+            console.log(`Transaction succeeded: ${committedTransaction.hash}`);
+        } else {
+            console.error(`Transaction failed: ${committedTransaction.hash}`);
+        }
+    });
+
+cliProgram
+    .command("get-state-info")
+    .description("Get all StorkState info")
+    .action(async () => { 
+        const contractAddress = DEFAULT_CONTRACT_ADDRESS;
+
+        const pubKeyResult = await aptos.view({
+            payload: {
+                function: `${contractAddress}::state::get_stork_evm_public_key`,
+            },
+        });
+
+        const parsedResult = JSON.parse(JSON.stringify(pubKeyResult[0]));
+        const storkEvmPublicKey = parsedResult.bytes;
+        console.log(`Stork EVM public key: ${storkEvmPublicKey}`);
+
+        const updateFeeResult = await aptos.view({
+            payload: {
+                function: `${contractAddress}::state::get_single_update_fee_in_octas`,
+            },
+        });
+        let updateFee = updateFeeResult[0] as number;
+        console.log(`Update fee: ${updateFee}`);
+
+        const ownerResult = await aptos.view({
+            payload: {
+                function: `${contractAddress}::state::get_owner`,
+            },
+        });
+        let owner = ownerResult[0] as string;
+        console.log(`Owner: ${owner}`);
+    });
+
+cliProgram
+    .command("set-owner")
+    .description("Set the owner")
+    .argument("owner", "The new owner")
+    .action(async (owner: string) => {
+        const account = getAccount();
+        const contractAddress = DEFAULT_CONTRACT_ADDRESS;
+        const tx = await aptos.transaction.build.simple({
+            sender: account.accountAddress,
+            data: {
+                function: `${contractAddress}::state::set_owner`,
+                functionArguments: [owner],
+            },
+        });
+        const senderAuthenticator = aptos.transaction.sign({
+            signer: account,
+            transaction: tx,
+        });
+
+        const committedTransaction = await aptos.transaction.submit.simple({
+            transaction: tx,
+            senderAuthenticator,
+        });
+
+        const executedTransaction = await aptos.waitForTransaction({ transactionHash: committedTransaction.hash });
+        if (executedTransaction.success) {
+            console.log(`Transaction succeeded: ${committedTransaction.hash}`);
+        } else {
+            console.error(`Transaction failed: ${committedTransaction.hash}`);
+        }
+    });
+
+cliProgram
+    .command("set-update-fee")
+    .description("Set the update fee")
+    .argument("fee", "The new fee")
+    .action(async (fee: number) => {
+        const account = getAccount();
+        const contractAddress = DEFAULT_CONTRACT_ADDRESS;
+        const tx = await aptos.transaction.build.simple({
+            sender: account.accountAddress,
+            data: {
+                function: `${contractAddress}::state::set_single_update_fee_in_octas`,
+                functionArguments: [fee],
+            },
+        });
+        const senderAuthenticator = aptos.transaction.sign({
+            signer: account,
+            transaction: tx,
+        });
+
+        const committedTransaction = await aptos.transaction.submit.simple({
+            transaction: tx,
+            senderAuthenticator,
+        });
+
+        const executedTransaction = await aptos.waitForTransaction({ transactionHash: committedTransaction.hash });
+        if (executedTransaction.success) {
+            console.log(`Transaction succeeded: ${committedTransaction.hash}`);
+        } else {
+            console.error(`Transaction failed: ${committedTransaction.hash}`);
+        }
+
+    });
+
+cliProgram
+    .command("set-stork-evm-public-key")
+    .description("Set the stork EVM public key")
+    .argument("key", "The new key")
+    .action(async (key: string) => {
+        const account = getAccount();
+        const contractAddress = DEFAULT_CONTRACT_ADDRESS;
+        const tx = await aptos.transaction.build.simple({
+            sender: account.accountAddress,
+            data: {
+                function: `${contractAddress}::state::set_stork_evm_public_key`,
+                functionArguments: [hexStringToByteArray(key)],
+            },
+        });
+        const senderAuthenticator = aptos.transaction.sign({
+            signer: account,
+            transaction: tx,
+        });
+        const committedTransaction = await aptos.transaction.submit.simple({
+            transaction: tx,
+            senderAuthenticator,
+        });
+        const executedTransaction = await aptos.waitForTransaction({ transactionHash: committedTransaction.hash });
+        if (executedTransaction.success) {
+            console.log(`Transaction succeeded: ${committedTransaction.hash}`);
+        } else {
+            console.error(`Transaction failed: ${committedTransaction.hash}`);
+        }
+    });
+cliProgram.parse();
+
+

contracts/aptos/cli/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "cli",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "@aptos-labs/ts-sdk": "^1.33.1",
+    "commander": "^13.0.0"
+  }
+}

contracts/aptos/cli/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "resolveJsonModule": true
+  },
+  "include": ["./**/*"],
+  "exclude": ["node_modules", "dist"]
+}

contracts/aptos/contracts/.gitignore

@@ -0,0 +1,2 @@
+.aptos/
+build/

contracts/aptos/contracts/Move.toml

@@ -0,0 +1,18 @@
+[package]
+name = "stork"
+version = "1.0.0"
+authors = []
+
+[addresses]
+stork = "_"
+
+
+[dev-addresses]
+stork = "0x101"
+
+[dependencies.AptosFramework]
+git = "https://github.com/aptos-labs/aptos-framework.git"
+rev = "mainnet"
+subdir = "aptos-framework"
+
+[dev-dependencies]

contracts/aptos/contracts/sources/encoded_asset_id.move

@@ -0,0 +1,81 @@
+module stork::encoded_asset_id {
+
+    // === Errors ===
+
+    /// The encoded asset id length is invalid
+    const E_INVALID_LENGTH: u64 = 0;
+
+    // === Constants ===
+
+    /// The length of an encoded asset id
+    const ASSET_ID_LENGTH: u64 = 32;
+
+    // === Structs ===
+
+    /// The encoded asset id struct
+    struct EncodedAssetId has copy, drop, store {
+        bytes: vector<u8>,
+    }
+
+    // === Functions ===
+
+    /// Creates a new encoded asset id from bytes
+    public fun from_bytes(bytes: vector<u8>): EncodedAssetId {
+        assert!(bytes.length() == ASSET_ID_LENGTH, E_INVALID_LENGTH);
+        EncodedAssetId {
+            bytes,
+        }
+    }
+
+    /// Gets the bytes of an encoded asset id
+    public fun get_bytes(self: &EncodedAssetId): vector<u8> {
+        self.bytes
+    }
+
+    // === Test Imports ===
+
+    #[test_only]
+    use std::vector;
+
+    // === Tests ===
+
+    #[test]
+    fun test_from_bytes() {
+        let bytes = create_zeroed_byte_vector(ASSET_ID_LENGTH);
+        let encoded_asset_id = from_bytes(bytes);
+        assert!(encoded_asset_id.bytes == bytes);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_INVALID_LENGTH)]
+    fun test_from_bytes_invalid_length() {
+        let bytes = create_zeroed_byte_vector(ASSET_ID_LENGTH + 1);
+        from_bytes(bytes);
+    }
+
+    #[test]
+    fun test_get_bytes() {
+        let bytes = create_zeroed_byte_vector(ASSET_ID_LENGTH);
+        let encoded_asset_id = from_bytes(bytes);
+        assert!(get_bytes(&encoded_asset_id) == bytes);
+    }
+
+    // === Test Helpers ===
+
+    #[test_only]
+    fun create_zeroed_byte_vector(length: u64): vector<u8> {
+        let zero = 0u8;
+        let bytes = vector::empty<u8>();
+        let i = 0;
+        while (i < length) {
+            bytes.push_back(zero);
+            i = i + 1;
+        };
+        bytes
+    }
+
+    #[test_only]
+    package fun create_zeroed_asset_id(): EncodedAssetId {
+        from_bytes(create_zeroed_byte_vector(ASSET_ID_LENGTH))
+    }
+}

contracts/aptos/contracts/sources/event.move

@@ -0,0 +1,46 @@
+module stork::event {
+
+    // === Imports ===
+
+    use aptos_std::event;
+    use stork::temporal_numeric_value::TemporalNumericValue;
+    use stork::encoded_asset_id::EncodedAssetId;
+    use stork::evm_pubkey::EvmPubKey;
+
+    // === Events ===
+
+    #[event]
+    /// Event emitted when the Stork contract is initialized
+    struct StorkInitializationEvent has drop, store{
+        stork_address: address,
+        stork_evm_public_key: EvmPubKey,
+        single_update_fee: u64,
+        owner: address,
+        state_account_address: address,
+    }
+
+    #[event]
+    /// Event emitted when a temporal numeric value is updated
+    struct TemporalNumericValueUpdateEvent has drop, store {
+        asset_id: EncodedAssetId,
+        temporal_numeric_value: TemporalNumericValue,
+    }
+
+    package fun emit_stork_initialization_event(
+        stork_address: address,
+        stork_evm_public_key: EvmPubKey,
+        single_update_fee: u64,
+        owner: address,
+        state_account_address: address,
+    ) {
+        event::emit(StorkInitializationEvent { stork_address, stork_evm_public_key, single_update_fee, owner, state_account_address });
+    }
+
+    package fun emit_temporal_numeric_value_update_event(
+        asset_id: EncodedAssetId,
+        temporal_numeric_value: TemporalNumericValue,
+    ) {
+        event::emit(TemporalNumericValueUpdateEvent { asset_id, temporal_numeric_value });
+    }
+
+}

contracts/aptos/contracts/sources/evm_pubkey.move

@@ -0,0 +1,79 @@
+module stork::evm_pubkey {
+
+    // === Errors ===
+
+    /// The EVM public key length is invalid
+    const E_INVALID_LENGTH: u64 = 0;
+
+    // === Constants ===
+
+    /// The length of an EVM public key
+    const EVM_PUBKEY_LENGTH: u64 = 20;
+
+    // === Structs ===
+
+    /// The EVM public key struct 
+    struct EvmPubKey has copy, drop, store {
+        /// Byte array of the EVM public key
+        bytes: vector<u8>,  
+    }
+
+    // === Functions ===
+
+    /// Creates a new EVM public key
+    public fun from_bytes(bytes: vector<u8>): EvmPubKey {
+        assert!(bytes.length() == EVM_PUBKEY_LENGTH, E_INVALID_LENGTH);
+        EvmPubKey { bytes }
+    }
+
+    /// Gets the bytes of the EVM public key
+    public fun get_bytes(self: &EvmPubKey): vector<u8> {
+        self.bytes
+    }
+
+    // === Test Imports ===
+
+    #[test_only]
+    use std::vector;
+
+    // === Tests ===
+
+    #[test]
+    fun test_from_bytes() {
+        let bytes = create_zeroed_byte_vector(EVM_PUBKEY_LENGTH); 
+        let evm_pubkey = from_bytes(bytes);
+        assert!(evm_pubkey.bytes == bytes);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_INVALID_LENGTH)]
+    fun test_from_bytes_invalid_length() {
+        let bytes = create_zeroed_byte_vector(EVM_PUBKEY_LENGTH + 1);
+        from_bytes(bytes);
+    }
+
+    #[test]
+    fun test_get_bytes() {
+        let bytes = create_zeroed_byte_vector(EVM_PUBKEY_LENGTH);
+        let evm_pubkey = from_bytes(bytes);
+        assert!(get_bytes(&evm_pubkey) == bytes);
+    }
+
+    #[test_only]
+    fun create_zeroed_byte_vector(length: u64): vector<u8> {
+        let zero = 0u8;
+        let i = 0;
+        let bytes = vector::empty<u8>();
+        while (i < length) {
+            bytes.push_back(zero);
+            i = i + 1;
+        };
+        bytes
+    }
+
+    #[test_only]
+    package fun create_zeroed_evm_pubkey(): EvmPubKey {
+        let bytes = create_zeroed_byte_vector(EVM_PUBKEY_LENGTH);
+        from_bytes(bytes)
+    }
+}

contracts/aptos/contracts/sources/i128.move

@@ -0,0 +1,232 @@
+module stork::i128 {
+
+    // === Imports ===
+
+    use std::vector;
+
+    // == Errors ===
+
+    /// The magnitude of the i128 is too large
+    const E_MAGNITUDE_TOO_LARGE: u64 = 0;
+    /// The sign of the i128 is invalid
+    const E_INVALID_SIGN: u64 = 1;
+
+    // === Constants ===
+
+    /// The maximum positive magnitude of an i128
+    const MAX_POSITIVE_MAGNITUDE: u128 = (1 << 127) - 1;
+    /// The maximum negative magnitude of an i128
+    const MAX_NEGATIVE_MAGNITUDE: u128 = (1 << 127);
+
+    // === Structs ===
+
+    /// The i128 struct
+    /// the magnitude is the absolute value of the number
+    /// positive 1 is represented as (1, false)
+    /// negative 1 is represented as (1, true)
+    struct I128 has copy, drop, store {
+        /// sign of the i128, True if positive, false if negative
+        negative: bool,
+        /// magnitude of the i128
+        magnitude: u128,
+    }
+
+    // === Public Functions ===
+
+    /// Creates a new i128
+    public fun new(magnitude: u128, negative: bool): I128 {
+        let negative = negative;
+        if (!negative) {
+            assert!(magnitude <= MAX_POSITIVE_MAGNITUDE, E_MAGNITUDE_TOO_LARGE);
+        } else {
+            assert!(magnitude <= MAX_NEGATIVE_MAGNITUDE, E_MAGNITUDE_TOO_LARGE);
+        };
+
+        // Ensure consistent 0 representation corresponding to twos complements(positive sign)
+        if (magnitude == 0) {
+            negative = false;
+        };
+        I128 { 
+            negative, 
+            magnitude 
+        }
+    }
+
+    /// Checks if the i128 is negative
+    public fun is_negative(self: &I128): bool {
+        self.negative
+    }
+
+    /// Gets the magnitude of the i128 if it is negative    
+    public fun get_magnitude_if_negative(self: &I128): u128 {
+        assert!(is_negative(self), E_INVALID_SIGN);
+        self.magnitude
+    }
+
+    /// Gets the magnitude of the i128 if it is positive
+    public fun get_magnitude_if_positive(self: &I128): u128 {
+        assert!(!is_negative(self), E_INVALID_SIGN);
+        self.magnitude
+    }
+
+    /// Gets the magnitude of the i128
+    public fun get_magnitude(self: &I128): u128 {
+        self.magnitude
+    }
+
+    /// Converts a u128 to an i128, assumes value is in twos complement representation
+    public fun from_u128(value: u128): I128 {
+        // Check the MSB for sign
+        let negative = (value >> 127) == 1;
+        if (!negative) {
+            // if positive, keep the value as is
+            new(value, false)
+        } else {
+            // if negative, convert from twos complement
+            let neg_value = (value ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) + 1;
+            new(neg_value, true)
+        }
+    }
+
+    /// Converts the I128 to a big-endian byte representation compatible with Ethereum's int256
+    public fun to_bytes(value: I128): vector<u8> {
+        let bytes = vector::empty<u8>();
+        let mut_value = if (value.negative) {
+            // convert to twos complement
+            (value.magnitude - 1) ^ 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+        } else {
+            value.magnitude
+        };
+
+        // Convert to big-endian bytes
+        let i = 16; // Start from most significant byte (16 bytes total)
+        while (i > 0) {
+            i = i - 1;
+            let byte = ((mut_value >> (i * 8)) & 0xFF as u8);
+            vector::push_back(&mut bytes, byte);
+        };
+
+        bytes
+    }
+
+    // === Tests ===
+
+    #[test]
+    fun test_max_positive_magnitude() {
+        let max_positive_magnitude = new(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, false);
+        assert!(!max_positive_magnitude.negative, 1);
+        assert!(max_positive_magnitude.magnitude == MAX_POSITIVE_MAGNITUDE, 1);
+        assert!(&new(1<<127 -1, false) == &from_u128(1<<127 -1), 1);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_MAGNITUDE_TOO_LARGE)]
+    fun test_magnitude_too_large_positive() {
+        let magnitude_too_large_positive = 0x80000000000000000000000000000000;
+        new(magnitude_too_large_positive, false);
+    }
+
+    #[test]
+    fun test_max_negative_magnitude() {
+        let max_negative_magnitude = new(0x80000000000000000000000000000000, true);
+        assert!(max_negative_magnitude.negative, 1);
+        assert!(max_negative_magnitude.magnitude == MAX_NEGATIVE_MAGNITUDE, 1);
+        assert!(&new(1<<127, true) == &from_u128(1<<127), 1);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_MAGNITUDE_TOO_LARGE)]
+    fun test_magnitude_too_large_negative() {
+        let magnitude_too_large_negative = 0x80000000000000000000000000000001;
+        new(magnitude_too_large_negative, true);
+    }
+
+    #[test]
+    fun test_is_negative() {
+        assert!(!is_negative(&new(1, false)), 1);
+        assert!(is_negative(&new(1, true)), 1);
+    }
+
+    #[test]
+    fun test_get_magnitude_if_negative_negative() {
+        assert!(get_magnitude_if_negative(&new(1, true)) == 1, 1);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_INVALID_SIGN)]
+    fun test_get_magnitude_if_negative_positive() {
+        get_magnitude_if_negative(&new(1, false));
+    }
+
+    #[test]
+    fun test_get_magnitude_if_positive_positive() {
+        assert!(get_magnitude_if_positive(&new(1, false)) == 1, 1);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_INVALID_SIGN)]
+    fun test_get_magnitude_if_positive_negative() {
+        get_magnitude_if_positive(&new(1, true));
+    }
+
+    #[test]
+    fun test_get_magnitude() {
+        assert!(get_magnitude(&new(1, false)) == 1, 0);
+        assert!(get_magnitude(&new(1, true)) == 1, 0);
+    }
+
+    #[test]
+    fun test_from_u128_positive() {
+        assert!(&new(1, false) == &from_u128(1), 1);
+    }
+
+    #[test]
+    fun test_from_u128_negative() {
+        assert!(&new(1, true) == &from_u128(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF), 1);
+    }
+
+    #[test]
+    fun test_single_representation_of_zero() {
+        assert!(&new(0, false) == &from_u128(0), 1);
+        assert!(&new(0, true) == &from_u128(0), 1);
+        let zero_positive = new(0, false);
+        let zero_negative = new(0, true);
+        assert!(&zero_positive == &zero_negative, 1);
+        assert!(!is_negative(&zero_positive), 1);
+        assert!(!is_negative(&zero_negative), 1);
+    }
+
+    #[test]
+    fun test_to_bytes_positive() {
+        let value = new(1, false); // Positive 1
+        let bytes = to_bytes(value);
+        assert!(bytes == x"00000000000000000000000000000001", 0);
+
+        let value = new(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, false); // Max positive
+        let bytes = to_bytes(value);
+        assert!(bytes == x"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0);
+    }
+
+    #[test]
+    fun test_to_bytes_negative() {
+        let value = new(1, true); // Negative 1
+        let bytes = to_bytes(value);
+        assert!(bytes == x"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 0);
+        let value = new(0x80000000000000000000000000000000, true); // Max negative
+        let bytes = to_bytes(value);
+        assert!(bytes == x"80000000000000000000000000000000", 0);
+    }
+
+    #[test]
+    fun test_to_bytes_zero() {
+        let value = new(0, false); // Zero
+        let bytes = to_bytes(value);
+        assert!(bytes == x"00000000000000000000000000000000", 0);
+
+        // Zero should be the same whether marked negative or positive
+        let value = new(0, true);
+        let bytes = to_bytes(value);
+        assert!(bytes == x"00000000000000000000000000000000", 0);
+    }
+
+}

contracts/aptos/contracts/sources/state.move

@@ -0,0 +1,195 @@
+module stork::state {
+    // === Imports ===  
+
+    use stork::evm_pubkey::{Self, EvmPubKey};
+    use stork::state_account_store;
+    use aptos_std::signer;
+
+    // === Errors ===
+
+    const E_NOT_OWNER: u64 = 0;
+
+    // == Structs ==
+
+    /// State object for the Stork contract
+    struct StorkState has key {
+        // Stork's EVM public key
+        stork_evm_public_key: EvmPubKey,
+        // fee for a single update
+        single_update_fee_in_octas: u64,
+        // owner of the Stork contract
+        owner: address,
+    }
+
+    // === Functions ===
+
+    /// Creates a new StorkState
+    package fun new(
+        stork_evm_public_key: EvmPubKey,
+        single_update_fee_in_octas: u64,
+        owner: address,
+    ): StorkState {
+        StorkState {
+            stork_evm_public_key,
+            single_update_fee_in_octas,
+            owner,
+        }
+    }
+
+    /// Moves a StorkState to the given signer
+    package fun move_state(self: StorkState, signer: &signer) {
+        move_to(signer, self);
+    }
+
+    #[view]
+    /// Returns the owner of the Stork contract
+    public fun get_owner(): address acquires StorkState {
+        borrow_global<StorkState>(state_account_store::get_state_account_address()).owner
+    }
+
+    #[view]
+    /// Returns the Stork's EVM public key
+    public fun get_stork_evm_public_key(): EvmPubKey acquires StorkState {
+        borrow_global<StorkState>(state_account_store::get_state_account_address()).stork_evm_public_key
+    }
+
+    #[view]
+    /// Returns the fee for a single update
+    public fun get_single_update_fee_in_octas(): u64 acquires StorkState {
+        borrow_global<StorkState>(state_account_store::get_state_account_address()).single_update_fee_in_octas
+    }
+
+    #[view]
+    /// Returns true if the state exists
+    public fun state_exists(): bool {
+        exists<StorkState>(state_account_store::get_state_account_address())
+    }
+
+    /// === Admin Functions ===
+
+    /// Sets the owner of the Stork contract
+    public entry fun set_owner(owner: &signer, new_owner: address) acquires StorkState {
+        let state = borrow_global_mut<StorkState>(state_account_store::get_state_account_address());
+        assert!(
+            signer::address_of(owner) == state.owner,
+            E_NOT_OWNER
+        );
+        state.owner = new_owner;
+    }
+
+    /// Sets the fee for a single update
+    public entry fun set_single_update_fee_in_octas(owner: &signer, new_fee_in_octas: u64) acquires StorkState {
+        let state = borrow_global_mut<StorkState>(state_account_store::get_state_account_address());
+        assert!(
+            signer::address_of(owner) == state.owner,
+            E_NOT_OWNER
+        );
+        state.single_update_fee_in_octas = new_fee_in_octas;
+    }
+
+    public entry fun set_stork_evm_public_key(owner: &signer, new_stork_evm_public_key: vector<u8>) acquires StorkState {
+        let state = borrow_global_mut<StorkState>(state_account_store::get_state_account_address());
+        assert!(
+            signer::address_of(owner) == state.owner,
+            E_NOT_OWNER
+        );
+        state.stork_evm_public_key = evm_pubkey::from_bytes(new_stork_evm_public_key);
+    }
+
+    // === Test Imports ===
+
+    #[test_only]
+    use aptos_framework::account::create_account_for_test;
+
+    // === Test Constants ===
+
+    #[test_only]
+    const STORK: address = @stork;
+    #[test_only]
+    const DEPLOYER: address = @0xFACE;
+    #[test_only]
+    const USER: address = @0xCAFE;
+
+    // === Test Helpers ===
+
+    #[test_only]
+    fun setup_test(): signer {
+        let stork_signer = create_account_for_test(STORK);
+        state_account_store::init_module_for_test(&stork_signer);
+        let deployer_signer = create_account_for_test(DEPLOYER);
+        let pubkey = evm_pubkey::create_zeroed_evm_pubkey();
+        let fee = 1;
+        let stork_state_account_signer = state_account_store::get_state_account_signer();
+
+        let state = new(pubkey, fee, DEPLOYER);
+        state.move_state(&stork_state_account_signer);
+        deployer_signer
+    }
+
+    // === Tests ===
+
+    #[test]
+    fun test_state_initialization() acquires StorkState {
+        setup_test();
+
+        assert!(state_exists(), 0);
+        assert!(get_single_update_fee_in_octas() == 1, 1);
+        assert!(get_stork_evm_public_key() == evm_pubkey::create_zeroed_evm_pubkey(), 3);
+        assert!(get_owner() == DEPLOYER, 5);
+    }
+
+    #[test]
+    fun test_set_owner() acquires StorkState {
+        let deployer_signer = setup_test();
+
+        set_owner(&deployer_signer, USER);
+        assert!(get_owner() == USER, 0);
+    }
+
+    #[test]
+    fun test_set_single_update_fee() acquires StorkState {
+        let deployer_signer = setup_test();
+
+        let new_fee = 200;
+        set_single_update_fee_in_octas(&deployer_signer, new_fee);
+
+        assert!(get_single_update_fee_in_octas() == new_fee, 0);
+    }
+
+    #[test]
+    fun test_set_stork_evm_public_key() acquires StorkState {
+        let deployer_signer = setup_test();
+
+        let new_stork_evm_public_key = x"0a803F9b1CCe32e2773e0d2e98b37E0775cA5d44";
+        set_stork_evm_public_key(&deployer_signer, new_stork_evm_public_key);
+
+        assert!(get_stork_evm_public_key() == evm_pubkey::from_bytes(new_stork_evm_public_key), 0);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_NOT_OWNER)]
+    fun test_set_owner_unauthorized() acquires StorkState {
+        setup_test();        
+
+        let user_signer = create_account_for_test(USER);
+        set_owner(&user_signer, USER);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_NOT_OWNER)]
+    fun test_set_fee_unauthorized() acquires StorkState {
+        setup_test();
+
+        let user_signer = create_account_for_test(USER);
+        set_single_update_fee_in_octas(&user_signer, 200);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_NOT_OWNER)]
+    fun test_set_stork_evm_public_key_unauthorized() acquires StorkState {
+        setup_test();
+
+        let user_signer = create_account_for_test(USER);
+        set_stork_evm_public_key(&user_signer, x"0a803F9b1CCe32e2773e0d2e98b37E0775cA5d44");
+    }
+}

contracts/aptos/contracts/sources/state_account_store.move

@@ -0,0 +1,87 @@
+module stork::state_account_store {
+
+    // === Imports ===
+
+    use aptos_framework::account::{Self, SignerCapability};
+
+    // === Constants ===
+
+    const STATE_ACCOUNT_SEED: vector<u8> = b"state-account";
+
+    // === Structs ===
+
+    struct StateAccountStore has key {
+        state_account_signer_cap: SignerCapability
+    }
+
+    // === Functions ===
+
+    /// Runs on publish, sets up the state account store
+    fun init_module(package: &signer){
+        let (_, state_account_signer_cap) = account::create_resource_account(package, STATE_ACCOUNT_SEED);
+        let state_account_store = new(state_account_signer_cap);
+        move_to(
+            package,
+            state_account_store
+        );
+    }
+
+    fun new(state_account_signer_cap: SignerCapability): StateAccountStore {
+        StateAccountStore {
+            state_account_signer_cap
+        }
+    }
+
+    #[view]
+    /// Returns the address of the state object
+    public fun get_state_account_address(): address acquires StateAccountStore {
+        let state_account_store = borrow_global<StateAccountStore>(@stork);
+        account::get_signer_capability_address(&state_account_store.state_account_signer_cap)
+    }
+
+    /// Returns the signer for the state object
+    package fun get_state_account_signer(): signer acquires StateAccountStore {
+        let state_account_store = borrow_global<StateAccountStore>(@stork);
+        account::create_signer_with_capability(&state_account_store.state_account_signer_cap)
+    }
+
+    // === Test Imports ===
+
+    #[test_only]
+    use aptos_std::signer;
+
+    // === Tests Constants ===
+
+    const STORK: address = @stork;
+
+    // === Test Helpers ===
+
+    #[test_only]
+    package fun init_module_for_test(package: &signer) {
+        init_module(package);
+    }
+
+    // === Tests ===
+
+    #[test]
+    fun test_state_account_store() {
+        let package = account::create_account_for_test(STORK);
+        init_module_for_test(&package);
+        assert!(exists<StateAccountStore>(STORK), 0);
+    }
+
+    #[test]
+    fun test_get_state_account_address() acquires StateAccountStore {
+        let package = account::create_account_for_test(STORK);
+        init_module_for_test(&package);
+        assert!(get_state_account_address() == account::create_resource_address(&STORK, STATE_ACCOUNT_SEED), 0);
+    }
+
+    #[test]
+    fun test_get_state_account_signer() acquires StateAccountStore {
+        let package = account::create_account_for_test(STORK);
+        init_module_for_test(&package);
+        let signer = get_state_account_signer();
+        assert!(signer::address_of(&signer) == account::create_resource_address(&STORK, STATE_ACCOUNT_SEED), 0);
+    }
+}

contracts/aptos/contracts/sources/temporal_numeric_value.move

@@ -0,0 +1,61 @@
+module stork::temporal_numeric_value {
+
+    // === Imports ===
+
+    use stork::i128::I128;
+
+    // === Structs ===
+
+    /// Struct representing a temporal numeric value
+    struct TemporalNumericValue has store, copy, drop{
+        /// The timestamp in nanoseconds
+        timestamp_ns: u64,
+        /// The quantized value
+        quantized_value: I128,
+    }
+
+    // === Functions ===
+
+    /// Creates a new temporal numeric value
+    public fun new(timestamp_ns: u64, quantized_value: I128): TemporalNumericValue {
+        TemporalNumericValue {
+            timestamp_ns,
+            quantized_value,
+        }
+    }
+
+    /// Returns the timestamp in nanoseconds
+    public fun get_timestamp_ns(self: &TemporalNumericValue): u64 {
+        self.timestamp_ns
+    }
+
+    /// Returns the quantized value
+    public fun get_quantized_value(self: &TemporalNumericValue): I128 {
+        self.quantized_value
+    }
+
+    // === Test Imports ===
+
+    #[test_only] use stork::i128;
+
+    // === Tests ===
+
+    #[test]
+    fun test_get_timestamp_ns() {
+        let value = new(1000, i128::from_u128(1000));
+        assert!(get_timestamp_ns(&value) == 1000);
+    }
+
+    #[test]
+    fun test_get_quantized_value() {
+        let value = new(1000, i128::from_u128(1000));
+        assert!(value.get_quantized_value() == i128::from_u128(1000));
+    }
+
+    // === Test Helpers ===
+
+    #[test_only]
+    package fun create_zeroed_temporal_numeric_value(): TemporalNumericValue {
+        new(0, i128::from_u128(0))
+    }
+}

contracts/aptos/contracts/sources/temporal_numeric_value_feed_registry.move

@@ -0,0 +1,148 @@
+module stork::temporal_numeric_value_feed_registry {
+
+    // === Imports ===
+
+    use aptos_std::table;
+    use stork::temporal_numeric_value::TemporalNumericValue;
+    use stork::encoded_asset_id::EncodedAssetId;
+    use stork::event::{emit_temporal_numeric_value_update_event};
+    use stork::state_account_store;
+
+    // === Errors ===
+
+    const E_FEED_NOT_FOUND: u64 = 0;
+
+    // === Structs ===
+
+    struct TemporalNumericValueFeedRegistry has key {
+        feed_table: table::Table<EncodedAssetId, TemporalNumericValue>,
+    }
+
+    // === Functions ===
+
+    package fun new(): TemporalNumericValueFeedRegistry {
+        TemporalNumericValueFeedRegistry {
+            feed_table: table::new(),
+        }
+    }
+
+    package fun move_tnv_feed_registry(self: TemporalNumericValueFeedRegistry, owner: &signer) {
+        move_to(owner, self);
+    }
+
+    package fun get_latest_canonical_temporal_numeric_value_unchecked(
+        asset_id: EncodedAssetId,
+    ): TemporalNumericValue acquires TemporalNumericValueFeedRegistry {
+        let feed_registry = borrow_global<TemporalNumericValueFeedRegistry>(state_account_store::get_state_account_address());
+        assert!(
+            feed_registry.feed_table.contains(asset_id),
+            E_FEED_NOT_FOUND
+        );
+        *table::borrow(&feed_registry.feed_table, asset_id)
+    }
+
+    package fun update_latest_temporal_numeric_value(
+        asset_id: EncodedAssetId,
+        temporal_numeric_value: TemporalNumericValue,
+    ) acquires TemporalNumericValueFeedRegistry {
+        let feed_registry = borrow_global_mut<TemporalNumericValueFeedRegistry>(state_account_store::get_state_account_address());
+        feed_registry.feed_table.upsert(asset_id, temporal_numeric_value);
+        emit_temporal_numeric_value_update_event(asset_id, temporal_numeric_value);
+    }
+
+    package fun contains(
+        asset_id: EncodedAssetId,
+    ): bool acquires TemporalNumericValueFeedRegistry {
+        let feed_registry = borrow_global<TemporalNumericValueFeedRegistry>(state_account_store::get_state_account_address());
+        feed_registry.feed_table.contains(asset_id)
+    }
+
+    // === Test Imports ===
+
+    #[test_only]
+    use aptos_framework::account::create_account_for_test;
+    #[test_only]
+    use stork::temporal_numeric_value;
+    #[test_only]
+    use stork::encoded_asset_id;
+
+    // === Test Constants ===
+
+    #[test_only]
+    const DEPLOYER: address = @0xFACE;
+    #[test_only]
+    const STORK: address = @stork;
+
+    // === Test Helpers ===
+
+    #[test_only]
+    fun setup_test(): signer {
+        let stork_signer = create_account_for_test(STORK);
+        state_account_store::init_module_for_test(&stork_signer);
+        let deployer_signer = create_account_for_test(DEPLOYER);
+        let stork_state_account_signer = state_account_store::get_state_account_signer();
+        let registry = new();
+
+        registry.move_tnv_feed_registry(&stork_state_account_signer);
+        deployer_signer
+    }
+
+    // === Tests ===
+
+    #[test]
+    fun test_update_and_get_value() acquires TemporalNumericValueFeedRegistry {
+        setup_test();
+
+        let asset_id = encoded_asset_id::create_zeroed_asset_id();
+        let value = temporal_numeric_value::create_zeroed_temporal_numeric_value();
+
+        assert!(!contains(asset_id), 0);
+
+        update_latest_temporal_numeric_value(asset_id, value);
+
+        assert!(contains(asset_id), 1);
+        let stored_value = get_latest_canonical_temporal_numeric_value_unchecked(asset_id);
+        assert!(stored_value == value, 2);
+    }
+
+    #[test]
+    fun test_multiple_updates() acquires TemporalNumericValueFeedRegistry {
+        setup_test();
+
+        let asset_id = encoded_asset_id::create_zeroed_asset_id();
+        let value1 = temporal_numeric_value::create_zeroed_temporal_numeric_value();
+        let value2 = temporal_numeric_value::create_zeroed_temporal_numeric_value();
+
+        update_latest_temporal_numeric_value(asset_id, value1);
+        update_latest_temporal_numeric_value(asset_id, value2);
+
+        let stored_value = get_latest_canonical_temporal_numeric_value_unchecked(asset_id);
+        assert!(stored_value == value2, 0);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = E_FEED_NOT_FOUND)]
+    fun test_get_nonexistent_feed() acquires TemporalNumericValueFeedRegistry {
+        setup_test();
+
+        let asset_id = encoded_asset_id::create_zeroed_asset_id();
+        get_latest_canonical_temporal_numeric_value_unchecked(asset_id);
+    }
+
+    #[test]
+    fun test_multiple_assets() acquires TemporalNumericValueFeedRegistry {
+        setup_test();
+
+        let asset_id1 = encoded_asset_id::create_zeroed_asset_id();
+        let asset_id2 = encoded_asset_id::create_zeroed_asset_id();
+        let value1 = temporal_numeric_value::create_zeroed_temporal_numeric_value();
+        let value2 = temporal_numeric_value::create_zeroed_temporal_numeric_value();
+
+        update_latest_temporal_numeric_value(asset_id1, value1);
+        update_latest_temporal_numeric_value(asset_id2, value2);
+
+        assert!(get_latest_canonical_temporal_numeric_value_unchecked(asset_id1) == value1, 0);
+        assert!(get_latest_canonical_temporal_numeric_value_unchecked(asset_id2) == value2, 1);
+    }
+
+}

contracts/aptos/contracts/sources/verify.move

@@ -0,0 +1,275 @@
+module stork::verify {
+
+    // === Imports ===
+
+    use stork::evm_pubkey::{Self, EvmPubKey};
+    use stork::i128::{Self, I128};
+    use aptos_std::secp256k1::{Self, ECDSASignature, ECDSARawPublicKey};
+    use aptos_std::aptos_hash::keccak256;
+    use std::vector;
+    use std::option;
+
+    // === Public Functions ===
+
+    /// Verifies an EVM signature of a stork signed update
+    public fun verify_evm_signature(
+        // EVM public key
+        stork_evm_public_key: &EvmPubKey,
+        // asset id
+        asset_id: vector<u8>,
+        // timestamp
+        recv_time: u64,
+        // quantized value
+        quantized_value: I128,
+        // publisher's merkle root
+        publisher_merkle_root: vector<u8>,
+        // value compute algorithm hash
+        value_compute_alg_hash: vector<u8>,
+        // signature r
+        r: vector<u8>,
+        // signature s
+        s: vector<u8>,
+        // signature v
+        v: u8,
+    ): bool {
+        let message = get_stork_message_hash(
+            stork_evm_public_key,
+            asset_id,
+            recv_time,
+            quantized_value,
+            publisher_merkle_root,
+            value_compute_alg_hash,
+        );
+
+        let signature = get_rs_signature_from_parts(r, s);
+        let recovery_id = get_recovery_id(v);
+        verify_ecdsa_signature(stork_evm_public_key, message, signature, recovery_id)
+    }
+
+
+    // === Private Functions ===
+
+    fun get_stork_message_bytes(
+        stork_evm_public_key: &EvmPubKey,
+        asset_id: vector<u8>,
+        recv_time: u64,
+        quantized_value: I128,
+        publisher_merkle_root: vector<u8>,
+        value_compute_alg_hash: vector<u8>,
+    ): vector<u8> {
+        let data = vector::empty();
+        data.append(evm_pubkey::get_bytes(stork_evm_public_key));
+        data.append(asset_id);
+
+        // left pad with 24 0 bytes
+        data.append(vector[0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+        let recv_time_bytes = vector::empty<u8>();
+        let i: u8 = 8;
+        while (i > 0) {
+            i = i - 1;
+            recv_time_bytes.push_back(((recv_time >> (i * 8)) & 0xFF) as u8);
+        };
+        data.append(recv_time_bytes);
+
+        //left pad with 16 0 bytes
+        data.append(vector[0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+        let value_bytes = i128::to_bytes(quantized_value);
+        data.append(value_bytes);
+        data.append(publisher_merkle_root);
+        data.append(value_compute_alg_hash);
+        data
+    }
+
+    fun get_stork_message_hash(
+        stork_evm_public_key: &EvmPubKey,
+        asset_id: vector<u8>,
+        recv_time: u64,
+        quantized_value: I128,
+        publisher_merkle_root: vector<u8>,
+        value_compute_alg_hash: vector<u8>,
+    ): vector<u8> {
+        keccak256(get_stork_message_bytes(stork_evm_public_key, asset_id, recv_time, quantized_value, publisher_merkle_root, value_compute_alg_hash))
+    }
+
+    fun get_recoverable_message(message: vector<u8>): vector<u8> {
+        // create the prefix "\x19Ethereum Signed Message:\n32"
+        let prefix = vector[0x19];
+        prefix.append(b"Ethereum Signed Message:\n32");
+        let data = vector::empty<u8>();
+        data.append(prefix);
+        data.append(message);
+        data
+    }
+
+    fun get_recoverable_message_hash(message: vector<u8>): vector<u8> {
+        keccak256(get_recoverable_message(message))
+    }
+
+    fun get_rs_signature_from_parts(
+        r: vector<u8>,
+        s: vector<u8>,
+    ): ECDSASignature {
+        let signature_bytes = vector::empty();
+        signature_bytes.append(r);
+        signature_bytes.append(s);
+
+        secp256k1::ecdsa_signature_from_bytes(signature_bytes)
+    }
+
+    fun verify_ecdsa_signature(
+        pubkey: &EvmPubKey,
+        message: vector<u8>,
+        signature: ECDSASignature,
+        recovery_id: u8,
+    ): bool {
+
+        let recoverable_message_hash = get_recoverable_message_hash(message);
+
+        let recovered_pubkey_option = secp256k1::ecdsa_recover(recoverable_message_hash, recovery_id, &signature);
+
+        if (recovered_pubkey_option == option::none()) {
+            return false;
+        };
+
+        let recovered_pubkey = recovered_pubkey_option.extract();
+        let evm_pubkey = get_evm_pubkey(recovered_pubkey);
+        evm_pubkey == *pubkey
+    }
+
+    fun get_evm_pubkey(pubkey: ECDSARawPublicKey): EvmPubKey {
+        let hashed = keccak256(secp256k1::ecdsa_raw_public_key_to_bytes(&pubkey));
+        let evm_address = vector::empty<u8>();
+        let i = 12;
+        while (i < 32) {
+            evm_address.push_back(hashed[i]);
+            i = i + 1;
+        };
+        evm_pubkey::from_bytes(evm_address)
+    }
+
+    fun get_recovery_id(v: u8): u8 {
+        v - 27
+    }
+
+// === Tests ===
+
+    #[test]
+    fun test_verify_evm_signature() {
+        let stork_public_key = evm_pubkey::from_bytes(x"0a803F9b1CCe32e2773e0d2e98b37E0775cA5d44");
+        let asset_id = x"7404e3d104ea7841c3d9e6fd20adfe99b4ad586bc08d8f3bd3afef894cf184de";
+        let recv_time = 1722632569208762117;
+        let quantized_value = i128::from_u128(62507457175499998000000);
+        let publisher_merkle_root = x"e5ff773b0316059c04aa157898766731017610dcbeede7d7f169bfeaab7cc318";
+        let value_compute_alg_hash = x"9be7e9f9ed459417d96112a7467bd0b27575a2c7847195c68f805b70ce1795ba";
+        let r = x"b9b3c9f80a355bd0cd6f609fff4a4b15fa4e3b4632adabb74c020f5bcd240741";
+        let s = x"16fab526529ac795108d201832cff8c2d2b1c710da6711fe9f7ab288a7149758";
+        let v = 28;
+
+        assert!(verify_evm_signature(
+            &stork_public_key,
+            asset_id,
+            recv_time,
+            quantized_value,
+            publisher_merkle_root,
+            value_compute_alg_hash,
+            r,
+            s,
+            v,
+        ), 0);
+    }
+
+    #[test]
+    fun test_get_stork_message_hash() {
+        let stork_public_key = evm_pubkey::from_bytes(x"0a803F9b1CCe32e2773e0d2e98b37E0775cA5d44");
+        let asset_id = x"7404e3d104ea7841c3d9e6fd20adfe99b4ad586bc08d8f3bd3afef894cf184de";
+        let recv_time = 1722632569208762117;
+        let quantized_value = i128::from_u128(62507457175499998000000);
+        let publisher_merkle_root = x"e5ff773b0316059c04aa157898766731017610dcbeede7d7f169bfeaab7cc318";
+        let value_compute_alg_hash = x"9be7e9f9ed459417d96112a7467bd0b27575a2c7847195c68f805b70ce1795ba";
+
+        let message_hash = get_stork_message_hash(
+            &stork_public_key,
+            asset_id,
+            recv_time,
+            quantized_value,
+            publisher_merkle_root,
+            value_compute_alg_hash,
+        );
+
+        assert!(message_hash == x"3102baf2e5ad5188e24d56f239915bed3a9a7b51754007dcbf3a65f81bae3084", 0);
+    }
+
+    #[test]
+    fun test_get_recoverable_message() {
+        let message = x"3102baf2e5ad5188e24d56f239915bed3a9a7b51754007dcbf3a65f81bae3084";
+        let recoverable_message = get_recoverable_message(message);
+        assert!(recoverable_message == x"19457468657265756d205369676e6564204d6573736167653a0a33323102baf2e5ad5188e24d56f239915bed3a9a7b51754007dcbf3a65f81bae3084", 0);
+    }
+
+    #[test]
+    fun test_get_rsv_signature() {
+        let r = x"b9b3c9f80a355bd0cd6f609fff4a4b15fa4e3b4632adabb74c020f5bcd240741";
+        let s = x"16fab526529ac795108d201832cff8c2d2b1c710da6711fe9f7ab288a7149758";
+        let signature = get_rs_signature_from_parts(r, s);
+        let signature_bytes = secp256k1::ecdsa_signature_to_bytes(&signature);
+
+        assert!(signature_bytes == x"b9b3c9f80a355bd0cd6f609fff4a4b15fa4e3b4632adabb74c020f5bcd24074116fab526529ac795108d201832cff8c2d2b1c710da6711fe9f7ab288a7149758", 0);
+
+    }
+
+    #[test]
+    fun test_get_recovery_id() {
+        let v = 28;
+        let recovery_id = get_recovery_id(v);
+        assert!(recovery_id == 1, 0);
+    }
+
+    #[test]
+    fun test_get_evm_pubkey() {
+        let evm_pubkey = evm_pubkey::from_bytes(x"E419C8cF64567DE0bd125e74bEAE3041BA2636B9");
+        let ecdsa_pubkey = secp256k1::ecdsa_raw_public_key_from_64_bytes(x"b10aec244e3ed4b584084cc61750f4d4c0140765bc72d8600c9208fe86d5c4842deadf18ddae210f57c4d89244c567622e3350421c298bfc94fc65e6195af261");
+        assert!(get_evm_pubkey(ecdsa_pubkey) == evm_pubkey, 0);
+    }
+
+    #[test]
+    fun test_verify_ecdsa_signature() {
+        let pubkey = evm_pubkey::from_bytes(x"0a803F9b1CCe32e2773e0d2e98b37E0775cA5d44");
+        let message = x"3102baf2e5ad5188e24d56f239915bed3a9a7b51754007dcbf3a65f81bae3084";
+        let r = x"b9b3c9f80a355bd0cd6f609fff4a4b15fa4e3b4632adabb74c020f5bcd240741";
+        let s = x"16fab526529ac795108d201832cff8c2d2b1c710da6711fe9f7ab288a7149758";
+        let v = 28;
+
+        let signature = get_rs_signature_from_parts(r, s);
+        let recovery_id = get_recovery_id(v);
+        assert!(verify_ecdsa_signature(&pubkey, message, signature, recovery_id), 0);
+    }
+
+    #[test]
+    #[expected_failure(abort_code = 0, location = stork::verify)]
+    fun test_verify_evm_signature_fails_with_wrong_value() {
+        let stork_public_key = evm_pubkey::from_bytes(x"0a803F9b1CCe32e2773e0d2e98b37E0775cA5d44");
+        let asset_id = x"7404e3d104ea7841c3d9e6fd20adfe99b4ad586bc08d8f3bd3afef894cf184de";
+        let recv_time = 1722632569208762117;
+        let quantized_value = i128::from_u128(62507457175499998000000 + 1); // Increment value by 1
+        let publisher_merkle_root = x"e5ff773b0316059c04aa157898766731017610dcbeede7d7f169bfeaab7cc318";
+        let value_compute_alg_hash = x"9be7e9f9ed459417d96112a7467bd0b27575a2c7847195c68f805b70ce1795ba";
+        let r = x"b9b3c9f80a355bd0cd6f609fff4a4b15fa4e3b4632adabb74c020f5bcd240741";
+        let s = x"16fab526529ac795108d201832cff8c2d2b1c710da6711fe9f7ab288a7149758";
+        let v = 28;
+
+        assert!(verify_evm_signature(
+            &stork_public_key,
+            asset_id,
+            recv_time,
+            quantized_value,
+            publisher_merkle_root,
+            value_compute_alg_hash,
+            r,
+            s,
+            v,
+        ), 0);
+    }
+
+}

examples/aptos/.gitignore

@@ -0,0 +1,2 @@
+.aptos/
+build/

examples/aptos/Move.toml

@@ -0,0 +1,25 @@
+[package]
+name = "example"
+version = "1.0.0"
+authors = []
+
+[addresses]
+example = "_"
+# TODO: Update this to the deployed address after the contract is deployed
+# Official addresses can be found at https://docs.stork.network/resources/contract-addresses/aptos
+stork = "0x68ba7261bf09152006999d7f53432ed540e238d8f1050e1fe739738309f58217"
+
+[dev-addresses]
+example = "0x101"
+
+[dependencies.AptosFramework]
+git = "https://github.com/aptos-labs/aptos-framework.git"
+rev = "mainnet"
+subdir = "aptos-framework"
+
+[dependencies.stork]
+git = "https://github.com/stork-oracle/stork-external.git"
+rev = "henry/sto-617-aptos-contract-implementation"
+subdir = "contracts/aptos/contracts"
+
+[dev-dependencies]

examples/aptos/README.md

@@ -0,0 +1,15 @@
+# Aptos Stork SDK Example
+This is a very simple Aptos project to show how you would use the Stork Aptos program to consume Stork price updates in your Aptos program.
+
+## Deploy locally
+1. Deploy a local version of the [Stork contract](../../contracts/aptos) 
+2. Initialize the contract and write some data to it for your desired asset id using the cli in [admin.ts](../../contracts/aptos/cli/admin.ts)
+3. Set the stork address in the example [Move.toml](./Move.toml)
+3. Compile and deploy this example contract.
+```bash
+aptos move deploy-object --address-name example --profile <profile_name> --move-2
+```
+4. Read the price from the Stork feed using the cli in [example.ts](./app/example.ts)
+```bash
+EXAMPLE_PACKAGE_ADDRESS=<package_address> RPC_ALIAS=<rpc_alias> PRIVATE_KEY=<private_key> npx ts-node ./app/example.ts read-price <asset_id>
+```

examples/aptos/app/.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+/dist

examples/aptos/app/example.ts

@@ -0,0 +1,66 @@
+import { Command } from "commander";
+import { Account, Aptos, AptosConfig, Network, Ed25519PrivateKey, PrivateKey, PrivateKeyVariants} from "@aptos-labs/ts-sdk";
+import keccak256 from 'keccak256';
+const EXAMPLE_PACKAGE_ADDRESS = process.env.EXAMPLE_PACKAGE_ADDRESS;
+const PRIVATE_KEY = process.env.PRIVATE_KEY;
+
+const APTOS_CONFIG = new AptosConfig({
+    network: process.env.RPC_ALIAS as Network,
+});
+
+const aptos = new Aptos(APTOS_CONFIG);
+
+function getAccount() {
+    if (!PRIVATE_KEY) {
+        throw new Error("PRIVATE_KEY is not set");
+    }
+
+    const formattedKey = PrivateKey.formatPrivateKey(PRIVATE_KEY, PrivateKeyVariants.Ed25519);
+    const privateKey = new Ed25519PrivateKey(formattedKey);
+    const account = Account.fromPrivateKey({ privateKey, legacy: true });
+    return account;
+}
+
+function hexStringToByteArray(hexString: string) {
+    if (hexString.startsWith("0x")) {
+      hexString = hexString.slice(2);
+    }
+    return Array.from(Buffer.from(hexString, "hex"));
+}
+
+const cliProgram = new Command();
+cliProgram
+    .name("stork-example")
+    .description("Aptos Stork example client")
+    .version("0.1.0");
+
+cliProgram
+    .command("read-price")
+    .description("Read price from Stork feed")
+    .argument("<asset>", "Asset identifier (will be hashed)")
+    .action(async (asset: string) => {
+        const account = getAccount();
+        const contractAddress = EXAMPLE_PACKAGE_ADDRESS;
+        const tx = await aptos.transaction.build.simple({
+            sender: account.accountAddress,
+            data: {
+                function: `${contractAddress}::example::use_stork_price`,
+                functionArguments: [keccak256(asset)],
+            },
+        });
+        const senderAuthenticator = aptos.transaction.sign({
+            signer: account,
+            transaction: tx,
+        });
+
+        const committedTransaction = await aptos.transaction.submit.simple({
+            transaction: tx,
+            senderAuthenticator,
+        });
+
+        const executedTransaction = await aptos.waitForTransaction({ transactionHash: committedTransaction.hash });
+        if (executedTransaction.success) {
+            console.log(`Transaction succeeded: ${committedTransaction.hash}`);
+        }
+    });
+cliProgram.parse();

examples/aptos/app/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "app",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@aptos-labs/ts-sdk": "^1.33.1",
+    "commander": "^13.0.0",
+    "keccak256": "^1.0.6"
+  }
+}

examples/aptos/app/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+      "target": "ES2020",
+      "module": "commonjs",
+      "strict": true,
+      "esModuleInterop": true,
+      "skipLibCheck": true,
+      "forceConsistentCasingInFileNames": true,
+      "outDir": "./dist"
+    }
+  }
+

examples/aptos/sources/example.move

@@ -0,0 +1,31 @@
+module example::example {
+
+    use stork::stork;
+    use aptos_framework::event;
+
+    #[event]
+    struct ExampleStorkPriceEvent has copy, drop, store {
+        timestamp: u64,
+        magnitude: u128,
+        negative: bool,
+    }
+
+    public entry fun use_stork_price(asset_id: vector<u8>) {
+        // Get the price
+        let price = stork::get_temporal_numeric_value_unchecked(asset_id);
+
+        let timestamp = price.get_timestamp_ns();
+        let i128value = price.get_quantized_value();
+
+        let magnitude = i128value.get_magnitude();
+        let negative = i128value.is_negative();
+
+        // Do something with the price
+        // example: emit an event
+        event::emit(ExampleStorkPriceEvent {
+            timestamp,
+            magnitude,
+            negative,
+        });
+    }
+}

go.mod

@@ -4,6 +4,7 @@ go 1.22.0
 
 require (
 	github.com/NethermindEth/juno v0.11.7
+	github.com/aptos-labs/aptos-go-sdk v1.4.1
 	github.com/coming-chat/go-sui/v2 v2.0.1
 	github.com/consensys/gnark-crypto v0.13.0
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
@@ -23,7 +24,7 @@ require (
 )
 
 require (
-	filippo.io/edwards25519 v1.0.0-rc.1 // indirect
+	filippo.io/edwards25519 v1.1.0 // indirect
 	github.com/Microsoft/go-winio v0.6.2 // indirect
 	github.com/andres-erbsen/clock v0.0.0-20160526145045-9e14626cd129 // indirect
 	github.com/bits-and-blooms/bitset v1.14.2 // indirect
@@ -43,6 +44,8 @@ require (
 	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
 	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/gorilla/rpc v1.2.0 // indirect
+	github.com/hasura/go-graphql-client v0.12.1 // indirect
+	github.com/hdevalence/ed25519consensus v0.2.0 // indirect
 	github.com/holiman/uint256 v1.3.1 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
@@ -79,5 +82,6 @@ require (
 	golang.org/x/sys v0.24.0 // indirect
 	golang.org/x/term v0.23.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
+	nhooyr.io/websocket v1.8.11 // indirect
 	rsc.io/tmplfunc v0.0.3 // indirect
 )

go.sum

@@ -1,5 +1,5 @@
-filippo.io/edwards25519 v1.0.0-rc.1 h1:m0VOOB23frXZvAOK44usCgLWvtsxIoMCTBGJZlpmGfU=
-filippo.io/edwards25519 v1.0.0-rc.1/go.mod h1:N1IkdkCkiLB6tki+MYJoSx2JTY9NUlxZE7eHn5EwJns=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 github.com/AlekSi/pointer v1.1.0 h1:SSDMPcXD9jSl8FPy9cRzoRaMJtm9g9ggGTxecRUbQoI=
 github.com/AlekSi/pointer v1.1.0/go.mod h1:y7BvfRI3wXPWKXEBhU71nbnIEEZX0QTSB2Bj48UJIZE=
 github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ=
@@ -13,6 +13,8 @@ github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkT
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/andres-erbsen/clock v0.0.0-20160526145045-9e14626cd129 h1:MzBOUgng9orim59UnfUTLRjMpd09C5uEVQ6RPGeCaVI=
 github.com/andres-erbsen/clock v0.0.0-20160526145045-9e14626cd129/go.mod h1:rFgpPQZYZ8vdbc+48xibu8ALc3yeyd64IhHS+PU6Yyg=
+github.com/aptos-labs/aptos-go-sdk v1.4.1 h1:foBM3FCLpxtjIO8hfmHHs3VcP5QY/sdAteNzOIpOcec=
+github.com/aptos-labs/aptos-go-sdk v1.4.1/go.mod h1:Ohl8Rq8mAGIbmzLll7nLAR+aPUdtzW8RtmyE0IDFib8=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
@@ -67,6 +69,12 @@ github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c h1:uQYC5Z1mdLR
 github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs=
 github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
 github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
+github.com/cucumber/gherkin/go/v26 v26.2.0 h1:EgIjePLWiPeslwIWmNQ3XHcypPsWAHoMCz/YEBKP4GI=
+github.com/cucumber/gherkin/go/v26 v26.2.0/go.mod h1:t2GAPnB8maCT4lkHL99BDCVNzCh1d7dBhCLt150Nr/0=
+github.com/cucumber/godog v0.14.1 h1:HGZhcOyyfaKclHjJ+r/q93iaTJZLKYW6Tv3HkmUE6+M=
+github.com/cucumber/godog v0.14.1/go.mod h1:FX3rzIDybWABU4kuIXLZ/qtqEe1Ac5RdXmqvACJOces=
+github.com/cucumber/messages/go/v21 v21.0.1 h1:wzA0LxwjlWQYZd32VTlAVDTkW6inOFmSM+RuOwHZiMI=
+github.com/cucumber/messages/go/v21 v21.0.1/go.mod h1:zheH/2HS9JLVFukdrsPWoPdmUtmYQAQPLk7w5vWsk5s=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -111,6 +119,8 @@ github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
 github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
+github.com/gofrs/uuid v4.3.1+incompatible h1:0/KbAdpx3UXAx1kEOWHJeOkpbgRFGHVgv+CFIY7dBJI=
+github.com/gofrs/uuid v4.3.1+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
@@ -134,6 +144,16 @@ github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aN
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE=
 github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0=
+github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
+github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-memdb v1.3.4 h1:XSL3NR682X/cVk2IeV0d70N4DZ9ljI885xAEU8IoK3c=
+github.com/hashicorp/go-memdb v1.3.4/go.mod h1:uBTr1oQbtuMgd1SSGoR8YV27eT3sBHbYiNm53bMpgSg=
+github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c=
+github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hasura/go-graphql-client v0.12.1 h1:tL+BCoyubkYYyaQ+tJz+oPe/pSxYwOJHwe5SSqqi6WI=
+github.com/hasura/go-graphql-client v0.12.1/go.mod h1:F4N4kR6vY8amio3gEu3tjSZr8GPOXJr3zj72DKixfLE=
+github.com/hdevalence/ed25519consensus v0.2.0 h1:37ICyZqdyj0lAZ8P4D1d1id3HqbbG1N3iBb1Tb4rdcU=
+github.com/hdevalence/ed25519consensus v0.2.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo=
 github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4=
 github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
@@ -374,5 +394,7 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nhooyr.io/websocket v1.8.11 h1:f/qXNc2/3DpoSZkHt1DQu6rj4zGC8JmkkLkWss0MgN0=
+nhooyr.io/websocket v1.8.11/go.mod h1:rN9OFWIUwuxg4fR5tELlYC04bXYowCP9GX47ivo2l+c=
 rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
 rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=