raydium amm Download - raydium amm Source Téléchargement

Raydium-Ram

Déploiements de programme

Environnement	PROGRAMME
MainNet	`675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8`
Devnet	`HWy1jotHpo6UqeQxx49dpYYdQB8wj9Qk9MdxwjLvDHB8`

Aperçu

Le Raydium AMM est un contrat intelligent sur chaîne basé sur le «produit constant» d'une manière sans autorisation et décentralisée construite sur la blockchain de Solana. Et il partage également sa liquidité en fonction de la séquence Fibonacci sous forme d'ordres limites sur OpenBook, le OpenBook, le OpenBook, le OpenBook, le OpenBook, le Fibonacci Central Limit Order Book (CLOB) de Solana
Le processus d'audit est là
Le document Dev est là

Configuration de l'environnement

Installez la rouille.
Installez Solana, puis exécutez solana-keygen new pour créer une cave à l'emplacement par défaut.

Construire

Clone le référentiel et entrez le répertoire de code source.

git clone https://github.com/raydium-io/raydium-amm
cd raydium-amm/program

Buillée MainNet

cargo build-bpf

DevNet Build

cargo build-bpf --features devnet

Build localnet

Vous devez mettre à jour ces pubkeys dans la "config_feature" comme la vôtre sur la fonctionnalité locale avant la construction;

cargo build-bpf --features localnet

Après la construction, les fichiers de contrat intelligent sont tous situés dans le répertoire cible.

Déployer

solana deploy

Attention, vérifiez votre configuration et confirmez l'environnement que vous souhaitez déployer.

Start

Vous devez avoir un marché Openbook qui n'est associé à aucun pool AMM si vous souhaitez initialiser un nouveau pool AMM. Et vous pouvez vous référer à ListMarket pour créer un nouveau marché.
Ajouter des dépendances dans votre cargo.toml

 [ dependencies ]
[ features ]
# default is mainnet
devnet = [
    "amm-cli/devnet" ,
    "common/devnet" ,
]

[ dependencies ]
amm-cli = { git = "https://github.com/raydium-io/raydium-library" }
common = { git = "https://github.com/raydium-io/raydium-library" }
spl-token = { version = "4.0.0" , features = [ "no-entrypoint" ] }
spl-associated-token-account = { version = "2.2.0" , features = [
    "no-entrypoint" ,
] }
spl-token- 2022 = { version = "0.9.0" , features = [ "no-entrypoint" ] }
solana-client = "<1.17.0"
solana-sdk = "<1.17.0"
anyhow = "1.0.53"
clap = { version = "4.1.8" , features = [ "derive" ] }

Importer des bibliothèques dépendantes

 #! [ allow ( dead_code ) ]
use anyhow :: { Ok , Result } ;
use clap :: Parser ;
use solana_client :: rpc_client :: RpcClient ;
use solana_sdk :: { commitment_config :: CommitmentConfig , signer :: Signer } ;
use std :: sync :: Arc ;

use {
    amm_cli :: { self , AmmCommands } ,
    common :: { common_types , common_utils , rpc } ,
} ;

Paramètres de configuration personnalisés dans votre code.

 // default config
let mut config = common_types :: CommonConfig :: default ( ) ;
// Replace the default configuration parameters you need
config . set_cluster ( "http" , "ws" ) ;
config . set_wallet ( "your wallet path" ) ;
config . set_amm_program ( "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8" ) ;
config . set_openbook_program ( "srmqPvymJeFKQ4zGQed1GFppgkRHL9kaELCbyksJtPX" ) ;
config . set_slippage ( 50 ) ;

Construire un objet de stockage signé.

 let payer = common_utils :: read_keypair_file ( & config . wallet ( ) ) ? ;
let fee_payer = payer . pubkey ( ) ;
let mut signing_keypairs : Vec < Arc < dyn Signer > > = Vec :: new ( ) ;
let payer : Arc < dyn Signer > = Arc :: new ( payer ) ;
if !signing_keypairs . contains ( & payer ) {
    signing_keypairs . push ( payer ) ;
}

Initialiser un nouveau pool AMM avec un marché ouverte associé

 // build initialize pool instruction
let subcmd = AmmCommands :: CreatePool {
    market : Pubkey :: from_str ( "The amm associated with openbook market" ) . unwrap ( ) ,
    coin_mint : Pubkey :: from_str ( "The openbook market's coin_mint" ) . unwrap ( ) ,
    pc_mint : Pubkey :: from_str ( "The openbook market's pc_mint" ) . unwrap ( ) ,
    user_token_coin : Pubkey :: from_str ( "User's token coin" ) . unwrap ( ) ,
    user_token_pc : Pubkey :: from_str ( "User's token pc" ) . unwrap ( ) ,
    init_coin_amount : 100000u64 ,
    init_pc_amount : 100000u64 ,
    open_time : 0 ,
} ;
let instruction = amm_cli :: process_amm_commands ( subcmd , & config ) . unwrap ( ) ;

déposer des actifs à une piscine AMM

 // build deposit instruction
let subcmd = AmmCommands :: Deposit {
    pool_id : Pubkey :: from_str ( "The specified pool of the assets deposite to" ) . unwrap ( ) ,
    deposit_token_coin : Some ( Pubkey :: from_str ( "The specified token coin of the user deposit" ) . unwrap ( ) ) ,
    deposit_token_pc : Some ( Pubkey :: from_str ( "The specified token pc of the user deposit" ) . unwrap ( ) ) ,
    recipient_token_lp : Some ( Pubkey :: from_str ( "The specified lp token of the user will receive" ) . unwrap ( ) ) ,
    amount_specified : 100000u64 ,
    another_min_limit : false ,
    base_coin : false ,
} ;
let instruction = amm_cli :: process_amm_commands ( subcmd , & config ) . unwrap ( ) ;

Note

Si le paramètre du dépôt_token_coin, dépôt_token_pc ou destinataire_token_lp est nul, ce sera le jeton ATA par défaut.

retirer les actifs de la piscine AMM

 // build withdraw instruction
let subcmd = AmmCommands :: Withdraw {
    pool_id : Pubkey :: from_str ( "The specified pool of the assets withdraw from" ) . unwrap ( ) ,
    withdraw_token_lp : Some ( Pubkey :: from_str ( "The specified lp token of the user withdraw" ) . unwrap ( ) ) ,
    recipient_token_coin : Some ( Pubkey :: from_str ( "The specified token coin of the user will receive" ) . unwrap ( ) ) ,
    recipient_token_pc : Some ( Pubkey :: from_str ( "The specified token pc of the user will receive" ) . unwrap ( ) ) ,
    input_lp_amount : 100000u64 ,
    slippage_limit : false ,
} ;
let instruction = amm_cli :: process_amm_commands ( subcmd , & config ) . unwrap ( ) ;

Note

Si le paramètre du retrait_token_lp, destinataire_token_coin ou destinataire_token_pc n'est aucun, ce sera le jeton ATA par défaut.

échanger

 // build swap instruction
let subcmd = AmmCommands :: Swap {
    pool_id : Pubkey :: from_str ( " The specified pool of trading" ) . unwrap ( ) ,
    user_input_token : Pubkey :: from_str ( "The token of user want to swap from" ) . unwrap ( ) ,
    user_output_token : Some ( Pubkey :: from_str ( "The token of user want to swap to" ) . unwrap ( ) ) ,
    amount_specified : 100000u64 ,
    base_out : false ,
} ;
let instruction = amm_cli :: process_amm_commands ( subcmd , & config ) . unwrap ( ) ;