Setup additional test/demo currencies

ocp/common/mint.go

@@ -22,7 +22,12 @@ var (
 
 	ErrUnsupportedMint = errors.New("unsupported mint")
 
-	jeffyMintAccount, _ = NewAccountFromPublicKeyString(config.JeffyMintPublicKey)
+	bitsMintAccount, _       = NewAccountFromPublicKeyString(config.BitsMintPublicKey)
+	bogeyMintAccount, _      = NewAccountFromPublicKeyString(config.BogeyMintPublicKey)
+	floatMintAccount, _      = NewAccountFromPublicKeyString(config.FloatMintPublicKey)
+	jeffyMintAccount, _      = NewAccountFromPublicKeyString(config.JeffyMintPublicKey)
+	marketCoinMintAccount, _ = NewAccountFromPublicKeyString(config.MarketCoinMintPublicKey)
+	xpMintAccount, _         = NewAccountFromPublicKeyString(config.XpMintPublicKey)
 )
 
 func GetBackwardsCompatMint(protoMint *commonpb.SolanaAccountId) (*Account, error) {

ocp/common/vm.go

@@ -12,9 +12,30 @@ var (
 	CoreMintVmOmnibusAccount, _ = NewAccountFromPublicKeyString(config.CoreMintVmOmnibusPublicKey)
 
 	// todo: DB store to track VM per mint
+
+	bitsAuthority, _        = NewAccountFromPublicKeyString(config.BitsAuthorityPublicKey)
+	bitsVmAccount, _        = NewAccountFromPublicKeyString(config.BitsVmAccountPublicKey)
+	bitsVmOmnibusAccount, _ = NewAccountFromPublicKeyString(config.BitsVmOmnibusPublicKey)
+
+	bogeyAuthority, _        = NewAccountFromPublicKeyString(config.BogeyAuthorityPublicKey)
+	bogeyVmAccount, _        = NewAccountFromPublicKeyString(config.BogeyVmAccountPublicKey)
+	bogeyVmOmnibusAccount, _ = NewAccountFromPublicKeyString(config.BogeyVmOmnibusPublicKey)
+
+	floatAuthority, _        = NewAccountFromPublicKeyString(config.FloatAuthorityPublicKey)
+	floatVmAccount, _        = NewAccountFromPublicKeyString(config.FloatVmAccountPublicKey)
+	floatVmOmnibusAccount, _ = NewAccountFromPublicKeyString(config.FloatVmOmnibusPublicKey)
+
 	jeffyAuthority, _        = NewAccountFromPublicKeyString(config.JeffyAuthorityPublicKey)
 	jeffyVmAccount, _        = NewAccountFromPublicKeyString(config.JeffyVmAccountPublicKey)
 	jeffyVmOmnibusAccount, _ = NewAccountFromPublicKeyString(config.JeffyVmOmnibusPublicKey)
+
+	marketCoinAuthority, _        = NewAccountFromPublicKeyString(config.MarketCoinAuthorityPublicKey)
+	marketCoinVmAccount, _        = NewAccountFromPublicKeyString(config.MarketCoinVmAccountPublicKey)
+	marketCoinVmOmnibusAccount, _ = NewAccountFromPublicKeyString(config.MarketCoinVmOmnibusPublicKey)
+
+	xpAuthority, _        = NewAccountFromPublicKeyString(config.XpAuthorityPublicKey)
+	xpVmAccount, _        = NewAccountFromPublicKeyString(config.XpVmAccountPublicKey)
+	xpVmOmnibusAccount, _ = NewAccountFromPublicKeyString(config.XpVmOmnibusPublicKey)
 )
 
 type VmConfig struct {
@@ -37,6 +58,63 @@ func GetVmConfigForMint(ctx context.Context, data ocp_data.Provider, mintAccount
 			Omnibus:   CoreMintVmOmnibusAccount,
 			Mint:      CoreMintAccount,
 		}, nil
+	case bitsMintAccount.PublicKey().ToBase58():
+		if bitsAuthority.PrivateKey() == nil {
+			vaultRecord, err := data.GetKey(ctx, bitsAuthority.PublicKey().ToBase58())
+			if err != nil {
+				return nil, err
+			}
+
+			bitsAuthority, err = NewAccountFromPrivateKeyString(vaultRecord.PrivateKey)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return &VmConfig{
+			Authority: bitsAuthority,
+			Vm:        bitsVmAccount,
+			Omnibus:   bitsVmOmnibusAccount,
+			Mint:      mintAccount,
+		}, nil
+	case bogeyMintAccount.PublicKey().ToBase58():
+		if bogeyAuthority.PrivateKey() == nil {
+			vaultRecord, err := data.GetKey(ctx, bogeyAuthority.PublicKey().ToBase58())
+			if err != nil {
+				return nil, err
+			}
+
+			bogeyAuthority, err = NewAccountFromPrivateKeyString(vaultRecord.PrivateKey)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return &VmConfig{
+			Authority: bogeyAuthority,
+			Vm:        bogeyVmAccount,
+			Omnibus:   bogeyVmOmnibusAccount,
+			Mint:      mintAccount,
+		}, nil
+	case floatMintAccount.PublicKey().ToBase58():
+		if floatAuthority.PrivateKey() == nil {
+			vaultRecord, err := data.GetKey(ctx, floatAuthority.PublicKey().ToBase58())
+			if err != nil {
+				return nil, err
+			}
+
+			floatAuthority, err = NewAccountFromPrivateKeyString(vaultRecord.PrivateKey)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return &VmConfig{
+			Authority: floatAuthority,
+			Vm:        floatVmAccount,
+			Omnibus:   floatVmOmnibusAccount,
+			Mint:      mintAccount,
+		}, nil
 	case jeffyMintAccount.PublicKey().ToBase58():
 		if jeffyAuthority.PrivateKey() == nil {
 			vaultRecord, err := data.GetKey(ctx, jeffyAuthority.PublicKey().ToBase58())
@@ -56,6 +134,44 @@ func GetVmConfigForMint(ctx context.Context, data ocp_data.Provider, mintAccount
 			Omnibus:   jeffyVmOmnibusAccount,
 			Mint:      mintAccount,
 		}, nil
+	case marketCoinMintAccount.PublicKey().ToBase58():
+		if marketCoinAuthority.PrivateKey() == nil {
+			vaultRecord, err := data.GetKey(ctx, marketCoinAuthority.PublicKey().ToBase58())
+			if err != nil {
+				return nil, err
+			}
+
+			marketCoinAuthority, err = NewAccountFromPrivateKeyString(vaultRecord.PrivateKey)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return &VmConfig{
+			Authority: marketCoinAuthority,
+			Vm:        marketCoinVmAccount,
+			Omnibus:   marketCoinVmOmnibusAccount,
+			Mint:      mintAccount,
+		}, nil
+	case xpMintAccount.PublicKey().ToBase58():
+		if xpAuthority.PrivateKey() == nil {
+			vaultRecord, err := data.GetKey(ctx, xpAuthority.PublicKey().ToBase58())
+			if err != nil {
+				return nil, err
+			}
+
+			xpAuthority, err = NewAccountFromPrivateKeyString(vaultRecord.PrivateKey)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return &VmConfig{
+			Authority: xpAuthority,
+			Vm:        xpVmAccount,
+			Omnibus:   xpVmOmnibusAccount,
+			Mint:      mintAccount,
+		}, nil
 	default:
 		return nil, ErrUnsupportedMint
 	}

ocp/config/config.go

@@ -24,10 +24,36 @@ const (
 	CoreMintVmOmnibusPublicKey = "D8oUTXRvarxhx9cjYdFJqWAVj2rmzry58bS6JSTiQsv5"
 
 	// todo: DB store to track VM per mint
+
+	BitsMintPublicKey      = "A3e8dzb1y4gqGP2cnCS3UU8dm5YNrFpZBpjjdoZdtfnB"
+	BitsAuthorityPublicKey = "bit8rCyAcstm1ZiwLq22FHdz8wAigKU46hmtrigrGub"
+	BitsVmAccountPublicKey = "5zDzL3CHb3wFxs7xnkxmWMGMR1gjNtYgV46PTBgSHmsJ"
+	BitsVmOmnibusPublicKey = "872F9FFXnSMPahkYjB8uF1pz1CrgMrmbfKQMGNCdVBvc"
+
+	BogeyMintPublicKey      = "3AhBb1fpDTp1F9hPkZjRPDejXBM9S5vfpVdvn66vLYnT"
+	BogeyAuthorityPublicKey = "bgy6SZdBCjVbftagjp4Vv5rvajTHmmh4ccsZbD9F3m3"
+	BogeyVmAccountPublicKey = "2KWN2ame8kZKfFc6iyNAWNZsTvByfo3Mrzue6NasNC5B"
+	BogeyVmOmnibusPublicKey = "H52LuBfwtBNZ3qrX8gqteF2mLx3EscdeUiryUC4fFFfR"
+
+	FloatMintPublicKey      = "5APqK9YUZupKt7rRUrpYy6WV3RPuxA71ZtKJffDUMdPP"
+	FloatAuthorityPublicKey = "f1t57oRwzBvtcqfAkjGKsEAbXymDSbL7pp3iRmDw9iz"
+	FloatVmAccountPublicKey = "5PKurz63VfSozHbkzwdudpDeA7mUuif8XTfNP932jRYy"
+	FloatVmOmnibusPublicKey = "98W5qFv7jiFvNA5c72kj7ku2hhFgaAEUfBXcLw8SK1yY"
+
 	JeffyMintPublicKey      = "54ggcQ23uen5b9QXMAns99MQNTKn7iyzq4wvCW6e8r25"
 	JeffyAuthorityPublicKey = "jfy1btcfsjSn2WCqLVaxiEjp4zgmemGyRsdCPbPwnZV"
 	JeffyVmAccountPublicKey = "8rwgUXsLSq1Pn51UJs4NGVA1cTkemwBgKyWPfFYgnm3B"
 	JeffyVmOmnibusPublicKey = "9XiqBPYSG2cBwpb8MqJeuFmLaQaAAr6gwikyBrPZDQ8R"
+
+	MarketCoinMintPublicKey      = "311m6Sb1814PfAxkEcqq6MNdBiVZLr8VWuAWDSC72euW"
+	MarketCoinAuthorityPublicKey = "mrkthxqn4rKCZw1pDxhJTpCrvUBtK9m6aLvCeY3PyWR"
+	MarketCoinVmAccountPublicKey = "AeJ6x6mtwdjUM2AqppQ7zG6m89sx5c8qegfFPzjmD2x6"
+	MarketCoinVmOmnibusPublicKey = "CQMdG8AKtLP9JCU4GAzKunKnsfpXVFdMcSwQd3Hd5oZg"
+
+	XpMintPublicKey      = "6oZnhB1FPrUaDfhRCVZnbVWNKVx9wgj84vKGH7eMpzXL"
+	XpAuthorityPublicKey = "xpTXV7BNXwsdvCaFKfeT4h6rSnKck2Bv5iBAFFS5Uwk"
+	XpVmAccountPublicKey = "4qnCaQkGxCnr66cmPfpNfM2rxaaTMFSSfbY9gXZgCYdS"
+	XpVmOmnibusPublicKey = "5FCroyNvCXpLFkNuNQ4fw8Lk8xNGwGpwoTjzhRMbaBUo"
 )
 
 var (

ocp/rpc/currency/worker.go

@@ -23,13 +23,23 @@ import (
 )
 
 var (
-	jeffyMintAccount, _ = common.NewAccountFromPublicKeyString(config.JeffyMintPublicKey)
+	bitsMintAccount, _       = common.NewAccountFromPublicKeyString(config.BitsMintPublicKey)
+	bogeyMintAccount, _      = common.NewAccountFromPublicKeyString(config.BogeyMintPublicKey)
+	floatMintAccount, _      = common.NewAccountFromPublicKeyString(config.FloatMintPublicKey)
+	jeffyMintAccount, _      = common.NewAccountFromPublicKeyString(config.JeffyMintPublicKey)
+	marketCoinMintAccount, _ = common.NewAccountFromPublicKeyString(config.MarketCoinMintPublicKey)
+	xpMintAccount, _         = common.NewAccountFromPublicKeyString(config.XpMintPublicKey)
 )
 
 // trackedLaunchpadMints is the hardcoded set of launchpad mints to track
 // (excludes core mint as it only has exchange rate data)
 var trackedLaunchpadMints = []*common.Account{
+	bitsMintAccount,
+	bogeyMintAccount,
+	floatMintAccount,
 	jeffyMintAccount,
+	marketCoinMintAccount,
+	xpMintAccount,
 }
 
 // liveExchangeRateData represents live exchange rate data with its pre-signed response

ocp/worker/currency/reserve.go

@@ -71,23 +71,113 @@ func (p *reserveRuntime) Start(runtimeCtx context.Context, interval time.Duratio
 // todo: Don't hardcode Jeffy and other Flipcash currencies
 func (p *reserveRuntime) UpdateAllLaunchpadCurrencyReserves(ctx context.Context) error {
 	err1 := func() error {
+		bitsMintAccount, _ := common.NewAccountFromPublicKeyString(config.BitsMintPublicKey)
+
+		ciculatingSupply, ts, err := currency_util.GetLaunchpadCurrencyCirculatingSupply(ctx, p.data, bitsMintAccount)
+		if err != nil {
+			return err
+		}
+
+		return p.data.PutCurrencyReserve(ctx, &currency.ReserveRecord{
+			Mint:              bitsMintAccount.PublicKey().ToBase58(),
+			SupplyFromBonding: ciculatingSupply,
+			Time:              ts,
+		})
+	}()
+
+	err2 := func() error {
+		bogeyMintAccount, _ := common.NewAccountFromPublicKeyString(config.BogeyMintPublicKey)
+
+		ciculatingSupply, ts, err := currency_util.GetLaunchpadCurrencyCirculatingSupply(ctx, p.data, bogeyMintAccount)
+		if err != nil {
+			return err
+		}
+
+		return p.data.PutCurrencyReserve(ctx, &currency.ReserveRecord{
+			Mint:              bogeyMintAccount.PublicKey().ToBase58(),
+			SupplyFromBonding: ciculatingSupply,
+			Time:              ts,
+		})
+	}()
+
+	err3 := func() error {
+		floatMintAccount, _ := common.NewAccountFromPublicKeyString(config.FloatMintPublicKey)
+
+		ciculatingSupply, ts, err := currency_util.GetLaunchpadCurrencyCirculatingSupply(ctx, p.data, floatMintAccount)
+		if err != nil {
+			return err
+		}
+
+		return p.data.PutCurrencyReserve(ctx, &currency.ReserveRecord{
+			Mint:              floatMintAccount.PublicKey().ToBase58(),
+			SupplyFromBonding: ciculatingSupply,
+			Time:              ts,
+		})
+	}()
+
+	err4 := func() error {
 		jeffyMintAccount, _ := common.NewAccountFromPublicKeyString(config.JeffyMintPublicKey)
 
-		jeffyCirculatingSupply, ts, err := currency_util.GetLaunchpadCurrencyCirculatingSupply(ctx, p.data, jeffyMintAccount)
+		ciculatingSupply, ts, err := currency_util.GetLaunchpadCurrencyCirculatingSupply(ctx, p.data, jeffyMintAccount)
 		if err != nil {
 			return err
 		}
 
 		return p.data.PutCurrencyReserve(ctx, &currency.ReserveRecord{
 			Mint:              jeffyMintAccount.PublicKey().ToBase58(),
-			SupplyFromBonding: jeffyCirculatingSupply,
+			SupplyFromBonding: ciculatingSupply,
+			Time:              ts,
+		})
+	}()
+
+	err5 := func() error {
+		marketCoinMintAccount, _ := common.NewAccountFromPublicKeyString(config.MarketCoinMintPublicKey)
+
+		ciculatingSupply, ts, err := currency_util.GetLaunchpadCurrencyCirculatingSupply(ctx, p.data, marketCoinMintAccount)
+		if err != nil {
+			return err
+		}
+
+		return p.data.PutCurrencyReserve(ctx, &currency.ReserveRecord{
+			Mint:              marketCoinMintAccount.PublicKey().ToBase58(),
+			SupplyFromBonding: ciculatingSupply,
+			Time:              ts,
+		})
+	}()
+
+	err6 := func() error {
+		xpMintAccount, _ := common.NewAccountFromPublicKeyString(config.XpMintPublicKey)
+
+		ciculatingSupply, ts, err := currency_util.GetLaunchpadCurrencyCirculatingSupply(ctx, p.data, xpMintAccount)
+		if err != nil {
+			return err
+		}
+
+		return p.data.PutCurrencyReserve(ctx, &currency.ReserveRecord{
+			Mint:              xpMintAccount.PublicKey().ToBase58(),
+			SupplyFromBonding: ciculatingSupply,
 			Time:              ts,
 		})
 	}()
 
 	if err1 != nil {
 		return err1
 	}
+	if err2 != nil {
+		return err2
+	}
+	if err3 != nil {
+		return err3
+	}
+	if err4 != nil {
+		return err4
+	}
+	if err5 != nil {
+		return err5
+	}
+	if err6 != nil {
+		return err6
+	}
 
 	return nil
 }

ocp/worker/geyser/handler.go

@@ -84,7 +84,13 @@ func (h *TokenProgramAccountHandler) Handle(ctx context.Context, update *geyserp
 	switch mintAccount.PublicKey().ToBase58() {
 
 	// todo: Don't hardcode Jeffy and other Flipcash currencies
-	case common.CoreMintAccount.PublicKey().ToBase58(), config.JeffyMintPublicKey:
+	case common.CoreMintAccount.PublicKey().ToBase58(),
+		config.BitsMintPublicKey,
+		config.BogeyMintPublicKey,
+		config.FloatMintPublicKey,
+		config.JeffyMintPublicKey,
+		config.MarketCoinMintPublicKey,
+		config.XpMintPublicKey:
 		// Not an ATA, so filter it out. It cannot be a VM deposit ATA
 		if bytes.Equal(tokenAccount.PublicKey().ToBytes(), ownerAccount.PublicKey().ToBytes()) {
 			return nil

ocp/worker/nonce/runtime.go

@@ -70,7 +70,12 @@ func (p *runtime) Start(ctx context.Context, interval time.Duration) error {
 	// todo: Dynamically detect VMs
 	for _, vm := range []string{
 		common.CoreMintVmAccount.PublicKey().ToBase58(),
+		config.BitsVmAccountPublicKey,
+		config.BogeyVmAccountPublicKey,
+		config.FloatVmAccountPublicKey,
 		config.JeffyVmAccountPublicKey,
+		config.MarketCoinVmAccountPublicKey,
+		config.XpVmAccountPublicKey,
 	} {
 		for _, state := range []nonce.State{
 			nonce.StateReleased,