@project-serum/anchor#BN TypeScript Examples

/**
   * Called by the keepers regularly to cache the oracle prices.
   * @param mockPrices Only used for testing purposes. An array of user-set prices.
   */
  async cacheOracle(mockPrices?: BN[]) {
    const oracles = this.cache.data.oracles;
    return await this.program.rpc.cacheOracle(
      oracles.map((x) => x.symbol),
      mockPrices ?? null,
      {
        accounts: {
          signer: this.wallet.publicKey,
          cache: this.cache.pubkey,
        },
        remainingAccounts: oracles
          .flatMap((x) => x.sources)
          .map((x) => ({
            isSigner: false,
            isWritable: false,
            pubkey: x.key,
          })),
      },
    );
  }

/**
   * TODO:
   * @param {Uint8Array} b
   * @param {number} [offset]
   * @returns {BN}
   * @memberof SignedNumberField
   */
  decode(b: Uint8Array, offset?: number): BN {
    const start = offset == undefined ? 0 : offset
    const data = b.slice(start, start + this.span)
    return new BN(data, undefined, "le").fromTwos(this.span * 8)
  }

// price number is bigUSD / bigAsset
// lots is USD lots / Asset lots
export function priceNumberToLots(
  price: number,
  baseDecimals: number,
  baseLotSize: BN,
  quoteDecimals: number,
  quoteLotSize: BN,
): BN {
  return new BN(
    Math.round(
      (price * Math.pow(10, quoteDecimals) * baseLotSize.toNumber()) /
        (Math.pow(10, baseDecimals) * quoteLotSize.toNumber()),
    ),
  );
}

async createSimpleElectorate({
    proposalThreshold,
    governor,
    govTokenMint,
    baseKP = Keypair.generate(),
  }: {
    proposalThreshold: BN;
    baseKP?: Keypair;
    governor: PublicKey;
    govTokenMint: PublicKey;
  }): Promise<PendingElectorate> {
    const [electorate, bump] = await findSimpleElectorateAddress(
      baseKP.publicKey
    );
    return {
      electorate,
      tx: new TransactionEnvelope(
        this.provider,
        [
          this.programs.SimpleVoter.instruction.initializeElectorate(
            bump,
            proposalThreshold,
            {
              accounts: {
                base: baseKP.publicKey,
                governor,
                electorate,
                govTokenMint,
                payer: this.provider.wallet.publicKey,
                systemProgram: SystemProgram.programId,
              },
            }
          ),
        ],
        [baseKP]
      ),
    };
  }

public async initializeMarket(
		marketIndex: BN,
		priceOracle: PublicKey,
		baseAssetReserve: BN,
		quoteAssetReserve: BN,
		periodicity: BN,
		pegMultiplier: BN = PEG_PRECISION,
		oracleSource: OracleSource = OracleSource.PYTH,
		marginRatioInitial = 2000,
		marginRatioPartial = 625,
		marginRatioMaintenance = 500
	): Promise<TransactionSignature> {
		if (this.getMarketsAccount().markets[marketIndex.toNumber()].initialized) {
			throw Error(`MarketIndex ${marketIndex.toNumber()} already initialized`);
		}

		const initializeMarketTx = await this.program.transaction.initializeMarket(
			marketIndex,
			baseAssetReserve,
			quoteAssetReserve,
			periodicity,
			pegMultiplier,
			oracleSource,
			marginRatioInitial,
			marginRatioPartial,
			marginRatioMaintenance,
			{
				accounts: {
					state: await this.getStatePublicKey(),
					admin: this.wallet.publicKey,
					oracle: priceOracle,
					markets: this.getStateAccount().markets,
				},
			}
		);
		return await this.txSender.send(initializeMarketTx, [], this.opts);
	}

/**
   * TODO:
   * @param {Uint8Array} b
   * @param {number} [offset]
   * @returns {BN}
   * @memberof NumberField
   */
  decode(b: Uint8Array, offset?: number): BN {
    const start = offset ?? 0
    const data = b.slice(start, start + this.span)
    return new BN(data, undefined, "le")
  }

constructor(args: {
    name: string;
    symbol: string;
    uri: string;
    sellerFeeBasisPoints: number;
    creators: Creator[] | null;
    maxNumberOfLines: BN;
    isMutable: boolean;
    maxSupply: BN;
    retainAuthority: boolean;
  }) {
    this.name = args.name;
    this.symbol = args.symbol;
    this.uri = args.uri;
    this.sellerFeeBasisPoints = args.sellerFeeBasisPoints;
    this.creators = args.creators;
    this.maxNumberOfLines = args.maxNumberOfLines;
    this.isMutable = args.isMutable;
    this.maxSupply = args.maxSupply;
    this.retainAuthority = args.retainAuthority;
  }

exerciseOptionTx = async (
  program: anchor.Program<PsyAmerican>,
  size: anchor.BN,
  optionMarket: PublicKey,
  optionTokenKey: PublicKey,
  exerciser: Keypair,
  optionAuthority: Keypair,
  exerciserOptionTokenSrc: PublicKey,
  underlyingAssetPoolKey: PublicKey,
  underlyingAssetDestKey: PublicKey,
  quoteAssetPoolKey: PublicKey,
  quoteAssetSrcKey: PublicKey,
  remainingAccounts: AccountMeta[],
  opts: { feeOwner?: PublicKey } = {}
) => {
  await program.rpc.exerciseOption(size, {
    accounts: {
      userAuthority: exerciser.publicKey,
      optionAuthority: optionAuthority.publicKey,
      optionMarket,
      optionMint: optionTokenKey,
      exerciserOptionTokenSrc: exerciserOptionTokenSrc,
      underlyingAssetPool: underlyingAssetPoolKey,
      underlyingAssetDest: underlyingAssetDestKey,
      quoteAssetPool: quoteAssetPoolKey,
      quoteAssetSrc: quoteAssetSrcKey,
      feeOwner: opts.feeOwner || FEE_OWNER_KEY,
      tokenProgram: TOKEN_PROGRAM_ID,
      systemProgram: SystemProgram.programId,
      clock: SYSVAR_CLOCK_PUBKEY,
    },
    remainingAccounts: remainingAccounts,
    signers: [exerciser],
  });
}