Implement Go interface to currency creator Solana program (WIP)

Author: jeffyanta

pkg/solana/currencycreator/accounts_currency_config.go

@@ -0,0 +1,97 @@
+package currencycreator
+
+import (
+	"bytes"
+	"crypto/ed25519"
+	"fmt"
+
+	"github.com/mr-tron/base58"
+)
+
+const (
+	DefaultMintMaxSupply = 21_000_000_000_000
+	DefaultMintDecimals  = 6
+)
+
+const (
+	MaxCurrencyConfigAccountNameLength   = 32
+	MaxCurrencyConfigAccountSymbolLength = 8
+)
+
+const (
+	CurrencyConfigAccountSize = (8 + //discriminator
+		32 + // authority
+		32 + // creator
+		32 + // mint
+		MaxCurrencyConfigAccountNameLength + // name
+		MaxCurrencyConfigAccountSymbolLength + // symbol
+		32 + // seed
+		8 + // max_supply
+		8 + // current_supply
+		1 + // decimal_places
+		1 + // bump
+		1 + // mint_bump
+		5) // padding
+)
+
+var CurrencyConfigAccountDiscriminator = []byte{byte(AccountTypeCurrencyConfig), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+
+type CurrencyConfigAccount struct {
+	Authority     ed25519.PublicKey
+	Creator       ed25519.PublicKey
+	Mint          ed25519.PublicKey
+	Name          string
+	Symbol        string
+	Seed          ed25519.PublicKey
+	MaxSupply     uint64
+	CurrentSupply uint64
+	DecimalPlaces uint8
+	Bump          uint8
+	MintBump      uint8
+}
+
+func (obj *CurrencyConfigAccount) Unmarshal(data []byte) error {
+	if len(data) < CurrencyConfigAccountSize {
+		return ErrInvalidAccountData
+	}
+
+	var offset int
+
+	var discriminator []byte
+	getDiscriminator(data, &discriminator, &offset)
+	if !bytes.Equal(discriminator, CurrencyConfigAccountDiscriminator) {
+		return ErrInvalidAccountData
+	}
+
+	getKey(data, &obj.Authority, &offset)
+	getKey(data, &obj.Creator, &offset)
+	getKey(data, &obj.Mint, &offset)
+	getFixedString(data, &obj.Name, MaxCurrencyConfigAccountNameLength, &offset)
+	getFixedString(data, &obj.Symbol, MaxCurrencyConfigAccountSymbolLength, &offset)
+	getKey(data, &obj.Seed, &offset)
+	getUint64(data, &obj.MaxSupply, &offset)
+	getUint64(data, &obj.CurrentSupply, &offset)
+	getUint8(data, &obj.DecimalPlaces, &offset)
+	getUint8(data, &obj.Bump, &offset)
+	getUint8(data, &obj.MintBump, &offset)
+	offset += 5 // padding
+
+	return nil
+}
+
+func (obj *CurrencyConfigAccount) String() string {
+	return fmt.Sprintf(
+		"CurrencyConfig{authority=%s,creator=%s,mint=%s,name=%s,symbol=%s,seed=%s,max_supply=%d,currency_supply=%d,decimal_places=%d,bump=%d,mint_bump=%d}",
+		base58.Encode(obj.Authority),
+		base58.Encode(obj.Creator),
+		base58.Encode(obj.Mint),
+		obj.Name,
+		obj.Symbol,
+		base58.Encode(obj.Seed),
+		obj.MaxSupply,
+		obj.CurrentSupply,
+		obj.DecimalPlaces,
+		obj.Bump,
+		obj.MintBump,
+	)
+}

pkg/solana/currencycreator/accounts_liquidity_pool.go

@@ -0,0 +1,123 @@
+package currencycreator
+
+import (
+	"bytes"
+	"crypto/ed25519"
+	"fmt"
+	"time"
+
+	"github.com/mr-tron/base58"
+)
+
+const (
+	LiquidityPoolAccountSize = (8 + //discriminator
+		32 + // authority
+		32 + // currency
+		32 + // target_mint
+		32 + // base_mint
+		32 + // vault_target
+		32 + // vault_base
+		32 + // fee_target
+		32 + // fee_base
+		4 + // buy_fee
+		4 + // sell_fee
+		8 + // created_unix_time
+		8 + // go_live_unix_time
+		8 + // purchase_cap
+		8 + // sale_cap
+		RawExponentialCurveSize + // curve
+		8 + // supply_from_baseonding
+		1 + // bump
+		1 + // currency_baseump
+		1 + // vault_target_baseump
+		1 + // vault_base_baseump
+		4) // padding
+)
+
+var LiquidityPoolAccountDiscriminator = []byte{byte(AccountTypeLiquidityPool), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+
+type LiquidityPoolAccount struct {
+	Authority         ed25519.PublicKey
+	Currency          ed25519.PublicKey
+	TargetMint        ed25519.PublicKey
+	BaseMint          ed25519.PublicKey
+	VaultTarget       ed25519.PublicKey
+	VaultBase         ed25519.PublicKey
+	FeeTarget         ed25519.PublicKey
+	FeeBase           ed25519.PublicKey
+	BuyFee            uint32
+	SellFee           uint32
+	CreatedUnixTime   int64
+	GoLiveUnixTime    int64
+	PurchaseCap       uint64
+	SaleCap           uint64
+	Curve             RawExponentialCurve
+	SupplyFromBonding uint64
+	Bump              uint8
+	CurrencyBump      uint8
+	VaultTargetBump   uint8
+	VaultBaseBump     uint8
+}
+
+func (obj *LiquidityPoolAccount) Unmarshal(data []byte) error {
+	if len(data) < LiquidityPoolAccountSize {
+		return ErrInvalidAccountData
+	}
+
+	var offset int
+
+	var discriminator []byte
+	getDiscriminator(data, &discriminator, &offset)
+	if !bytes.Equal(discriminator, LiquidityPoolAccountDiscriminator) {
+		return ErrInvalidAccountData
+	}
+
+	getKey(data, &obj.Authority, &offset)
+	getKey(data, &obj.Currency, &offset)
+	getKey(data, &obj.TargetMint, &offset)
+	getKey(data, &obj.BaseMint, &offset)
+	getKey(data, &obj.VaultTarget, &offset)
+	getKey(data, &obj.VaultBase, &offset)
+	getKey(data, &obj.FeeTarget, &offset)
+	getKey(data, &obj.FeeBase, &offset)
+	getUint32(data, &obj.BuyFee, &offset)
+	getUint32(data, &obj.SellFee, &offset)
+	getInt64(data, &obj.CreatedUnixTime, &offset)
+	getInt64(data, &obj.GoLiveUnixTime, &offset)
+	getUint64(data, &obj.PurchaseCap, &offset)
+	getUint64(data, &obj.SaleCap, &offset)
+	getRawExponentialCurve(data, &obj.Curve, &offset)
+	getUint64(data, &obj.SupplyFromBonding, &offset)
+	getUint8(data, &obj.Bump, &offset)
+	getUint8(data, &obj.CurrencyBump, &offset)
+	getUint8(data, &obj.VaultTargetBump, &offset)
+	getUint8(data, &obj.VaultBaseBump, &offset)
+	offset += 4 // padding
+
+	return nil
+}
+
+func (obj *LiquidityPoolAccount) String() string {
+	return fmt.Sprintf(
+		"LiquidityPool{authority=%s,currency=%s,target_mint=%s,base_mint=%s,vault_target=%s,vault_base=%s,fee_target=%s,fee_base=%s,buy_fee=%d,sell_fee=%d,created_unix_time=%s,go_live_unix_time=%s,purchase_cap=%d,sale_cap=%d,curve=%s,bump=%d,currency_bump=%d,vault_target_bump=%d,vault_base_bump=%d}",
+		base58.Encode(obj.Authority),
+		base58.Encode(obj.Currency),
+		base58.Encode(obj.TargetMint),
+		base58.Encode(obj.BaseMint),
+		base58.Encode(obj.VaultTarget),
+		base58.Encode(obj.VaultBase),
+		base58.Encode(obj.FeeTarget),
+		base58.Encode(obj.FeeBase),
+		obj.BuyFee,
+		obj.SellFee,
+		time.Unix(obj.CreatedUnixTime, 0).UTC().String(),
+		time.Unix(obj.GoLiveUnixTime, 0).UTC().String(),
+		obj.PurchaseCap,
+		obj.SaleCap,
+		obj.Curve.String(),
+		obj.Bump,
+		obj.CurrencyBump,
+		obj.VaultTargetBump,
+		obj.VaultBaseBump,
+	)
+}

pkg/solana/currencycreator/address.go

@@ -0,0 +1,82 @@
+package currencycreator
+
+import (
+	"crypto/ed25519"
+
+	"github.com/code-payments/code-server/pkg/solana"
+)
+
+var (
+	MintPrefix     = []byte("mint")
+	CurrencyPrefix = []byte("currency")
+	PoolPrefix     = []byte("pool")
+	TreasuryPrefix = []byte("treasury")
+	MetadataPrefix = []byte("metadata")
+)
+
+type GetMintAddressArgs struct {
+	Authority ed25519.PublicKey
+	Name      string
+	Seed      ed25519.PublicKey
+}
+
+func GetMintAddress(args *GetMintAddressArgs) (ed25519.PublicKey, uint8, error) {
+	return solana.FindProgramAddressAndBump(
+		PROGRAM_ID,
+		MintPrefix,
+		args.Authority,
+		[]byte(toFixedString(args.Name, MaxCurrencyConfigAccountNameLength)),
+		args.Seed,
+	)
+}
+
+type GetCurrencyAddressArgs struct {
+	Mint ed25519.PublicKey
+}
+
+func GetCurrencyAddress(args *GetCurrencyAddressArgs) (ed25519.PublicKey, uint8, error) {
+	return solana.FindProgramAddressAndBump(
+		PROGRAM_ID,
+		CurrencyPrefix,
+		args.Mint,
+	)
+}
+
+type GetPoolAddressArgs struct {
+	Currency ed25519.PublicKey
+}
+
+func GetPoolAddress(args *GetPoolAddressArgs) (ed25519.PublicKey, uint8, error) {
+	return solana.FindProgramAddressAndBump(
+		PROGRAM_ID,
+		PoolPrefix,
+		args.Currency,
+	)
+}
+
+type GetVaultAddressArgs struct {
+	Pool ed25519.PublicKey
+	Mint ed25519.PublicKey
+}
+
+func GetVaultAddress(args *GetVaultAddressArgs) (ed25519.PublicKey, uint8, error) {
+	return solana.FindProgramAddressAndBump(
+		PROGRAM_ID,
+		TreasuryPrefix,
+		args.Pool,
+		args.Mint,
+	)
+}
+
+type GetMetadataAddressArgs struct {
+	Mint ed25519.PublicKey
+}
+
+func GetMetadataAddress(args *GetMetadataAddressArgs) (ed25519.PublicKey, uint8, error) {
+	return solana.FindProgramAddressAndBump(
+		METADATA_PROGRAM_ID,
+		MetadataPrefix,
+		METADATA_PROGRAM_ID,
+		args.Mint,
+	)
+}

pkg/solana/currencycreator/estimate.go

@@ -0,0 +1,75 @@
+package currencycreator
+
+import (
+	"math"
+	"math/big"
+)
+
+func EstimateCurrentPrice(
+	curve *ExponentialCurve,
+	currentSupplyInQuarks uint64,
+	decimals uint8,
+) *big.Float {
+	scale := big.NewFloat(math.Pow10(int(decimals))).SetPrec(defaultExponentialCurvePrec)
+	unscaledCurrentSupply := big.NewFloat(float64(currentSupplyInQuarks)).SetPrec(defaultExponentialCurvePrec)
+	scaledCurrentSupply := new(big.Float).Quo(unscaledCurrentSupply, scale)
+	return curve.SpotPriceAtSupply(scaledCurrentSupply)
+}
+
+func EstimateBuy(
+	curve *ExponentialCurve,
+	buyAmountInQuarks,
+	currentSupplyInQuarks uint64,
+	buyFee uint32,
+	targetMintDecimals,
+	baseMintDecimals uint8,
+) (uint64, uint64) {
+	scale := big.NewFloat(math.Pow10(int(baseMintDecimals))).SetPrec(defaultExponentialCurvePrec)
+	unscaledBuyAmount := big.NewFloat(float64(buyAmountInQuarks)).SetPrec(defaultExponentialCurvePrec)
+	scaledBuyAmount := new(big.Float).Quo(unscaledBuyAmount, scale)
+
+	scale = big.NewFloat(math.Pow10(int(targetMintDecimals))).SetPrec(defaultExponentialCurvePrec)
+	unscaledCurrentSupply := big.NewFloat(float64(currentSupplyInQuarks)).SetPrec(defaultExponentialCurvePrec)
+	scaledCurrentSupply := new(big.Float).Quo(unscaledCurrentSupply, scale)
+
+	scale = big.NewFloat(math.Pow10(int(targetMintDecimals))).SetPrec(defaultExponentialCurvePrec)
+	scaledTotalValue := curve.ValueToTokens(scaledCurrentSupply, scaledBuyAmount)
+	unscaledTotalValue := new(big.Float).Mul(scaledTotalValue, scale)
+	total, _ := unscaledTotalValue.Int64()
+
+	feePctValue := new(big.Float).SetPrec(defaultExponentialCurvePrec).Quo(big.NewFloat(float64(buyFee)), big.NewFloat(10000))
+	scaledFees := new(big.Float).Mul(scaledTotalValue, feePctValue)
+	unscaledFees := new(big.Float).Mul(scaledFees, scale)
+	fees, _ := unscaledFees.Int64()
+
+	return uint64(total - fees), uint64(fees)
+}
+
+func EstimateSale(
+	curve *ExponentialCurve,
+	sellAmountInQuarks,
+	currentSupplyInQuarks uint64,
+	sellFee uint32,
+	targetMintDecimals,
+	baseMintDecimals uint8,
+) (uint64, uint64) {
+	scale := big.NewFloat(math.Pow10(int(targetMintDecimals))).SetPrec(defaultExponentialCurvePrec)
+	unscaledSellAmount := big.NewFloat(float64(sellAmountInQuarks)).SetPrec(defaultExponentialCurvePrec)
+	scaledSellAmount := new(big.Float).Quo(unscaledSellAmount, scale)
+
+	scale = big.NewFloat(math.Pow10(int(targetMintDecimals))).SetPrec(defaultExponentialCurvePrec)
+	unscaledCurrentSupply := big.NewFloat(float64(currentSupplyInQuarks)).SetPrec(defaultExponentialCurvePrec)
+	scaledCurrentSupply := new(big.Float).Quo(unscaledCurrentSupply, scale)
+
+	scale = big.NewFloat(math.Pow10(int(baseMintDecimals))).SetPrec(defaultExponentialCurvePrec)
+	scaledTotalValue := curve.TokensToValue(scaledCurrentSupply, scaledSellAmount)
+	unscaledTotalValue := new(big.Float).Mul(scaledTotalValue, scale)
+	total, _ := unscaledTotalValue.Int64()
+
+	feePctValue := new(big.Float).SetPrec(defaultExponentialCurvePrec).Quo(big.NewFloat(float64(sellFee)), big.NewFloat(10000))
+	scaledFees := new(big.Float).Mul(scaledTotalValue, feePctValue)
+	unscaledFees := new(big.Float).Mul(scaledFees, scale)
+	fees, _ := unscaledFees.Int64()
+
+	return uint64(total - fees), uint64(fees)
+}