@project-serum/anchor#Program TypeScript Examples

/**
   * Loads a new Cache object from its public key.
   * @param program
   * @param k The cache account's public key.
   * @param st
   */
  static async load(program: Program<Zo>, k: PublicKey, st: StateSchema) {
    return new this(program, k, await Cache.fetch(program, k, st), st);
  }

getMetadata = async (
  program: Program<Idl>,
  candyMachineId: web3.PublicKey
) => {
  const state: any = await program.account.candyMachine.fetch(candyMachineId);
  const itemsAvailable = state.data.itemsAvailable.toNumber();
  const itemsRedeemed = state.itemsRedeemed.toNumber();
  const itemsRemaining = itemsAvailable - itemsRedeemed;

  return {
    id: candyMachineId,
    program,
    state: {
      itemsAvailable,
      itemsRedeemed,
      itemsRemaining,
      isSoldOut: itemsRemaining === 0,
      isActive:
        state.data.goLiveDate.toNumber() < new Date().getTime() / 1000 &&
        (state.endSettings
          ? state.endSettings.endSettingType.date
            ? state.endSettings.number.toNumber() > new Date().getTime() / 1000
            : itemsRedeemed < state.endSettings.number.toNumber()
          : true),
      goLiveDate: state.data.goLiveDate,
      treasury: state.wallet,
      tokenMint: state.tokenMint,
      gatekeeper: state.data.gatekeeper,
      endSettings: state.data.endSettings,
      whitelistMintSettings: state.data.whitelistMintSettings,
      hiddenSettings: state.data.hiddenSettings,
      price: state.data.price,
    },
  };
}

createSunnyPool = async ({
  provider,
  rewarder,
  quarry,
}: {
  provider: Provider;
  rewarder: PublicKey;
  quarry: PublicKey;
}): Promise<{ sunnyPool: PublicKey; internalMint: PublicKey }> => {
  const sunny = new Program(SunnyPoolQuarryJSON, SUNNY_PROGRAM);
  // set up the sunny pool
  const [pool, bump] = await generateSunnyPoolAddress({
    quarry,
  });
  const sunnyMintKP = Keypair.generate();
  const createInternalMint = await createInitMintInstructions({
    provider,
    mintKP: sunnyMintKP,
    decimals: 6,
    mintAuthority: pool,
    freezeAuthority: pool,
  });
  const newPoolIx = sunny.instruction.newPool(bump, {
    accounts: {
      creator: SUNNY_CREATOR_KEY,
      rewarder,
      quarry,
      pool,
      payer: provider.wallet.publicKey,
      systemProgram: SystemProgram.programId,
      internalMint: sunnyMintKP.publicKey,
    },
  });
  await expectTX(
    createInternalMint.combine(new TransactionEnvelope(provider, [newPoolIx])),
    "create sunny pool"
  ).to.be.fulfilled;
  return { sunnyPool: pool, internalMint: sunnyMintKP.publicKey };
}

async function createDialectAndSubscribeAllMembers(
  program: Program,
  owner: anchor.web3.Keypair,
  member: anchor.web3.Keypair,
  encrypted: boolean,
) {
  const members: Member[] = [
    {
      publicKey: owner.publicKey,
      scopes: [true, true], // owner, read-only
    },
    {
      publicKey: member.publicKey,
      scopes: [false, true], // non-owner, read-write
    },
  ];
  const dialect = await createDialect(program, owner, members, encrypted);
  await subscribeUser(program, dialect, owner.publicKey, owner);
  await subscribeUser(program, dialect, member.publicKey, member);
  return dialect;
}

public constructor(
		program: Program,
		authority: PublicKey,
		accountLoader: BulkAccountLoader
	) {
		this.isSubscribed = false;
		this.program = program;
		this.authority = authority;
		this.accountLoader = accountLoader;
		this.eventEmitter = new EventEmitter();
	}

/**
   * Creates a connection to the authentication program.
   * @static
   * @param {Provider} provider
   * @returns {Promise<Program<AuthIdl>>}
   * @memberof Auth
   */
  static connect(provider: Provider): Promise<Program<AuthIdl>> {
    return connect(Auth.PROGRAM_ID, provider)
  }

async function signWithRetry(
  anchorProgram: Program,
  creatorKeyPair: Keypair,
  metadataAddress: PublicKey,
) {
  await sendTransactionWithRetryWithKeypair(
    anchorProgram.provider.connection,
    creatorKeyPair,
    [
      signMetadataInstruction(
        new PublicKey(metadataAddress),
        creatorKeyPair.publicKey,
      ),
    ],
    [],
    'single',
  );
}

initOptionMarket = async (
  program: anchor.Program<PsyAmerican>,
  payer: Keypair,
  optionMarket: OptionMarketV2,
  remainingAccounts: AccountMeta[],
  instructions: TransactionInstruction[]
) => {
  await program.rpc.initializeMarket(
    optionMarket.underlyingAmountPerContract,
    optionMarket.quoteAmountPerContract,
    optionMarket.expirationUnixTimestamp,
    optionMarket.bumpSeed,
    {
      accounts: {
        authority: payer.publicKey,
        underlyingAssetMint: optionMarket.underlyingAssetMint,
        quoteAssetMint: optionMarket.quoteAssetMint,
        optionMint: optionMarket.optionMint,
        writerTokenMint: optionMarket.writerTokenMint,
        quoteAssetPool: optionMarket.quoteAssetPool,
        underlyingAssetPool: optionMarket.underlyingAssetPool,
        optionMarket: optionMarket.key,
        feeOwner: FEE_OWNER_KEY,
        tokenProgram: TOKEN_PROGRAM_ID,
        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
        rent: SYSVAR_RENT_PUBKEY,
        systemProgram: SystemProgram.programId,
        clock: SYSVAR_CLOCK_PUBKEY,
      },
      remainingAccounts,
      signers: [payer],
      instructions,
    }
  );
}

export async function loadAuctionHouseProgram(
	connection: Connection,
	signer: IWalletSigner
) {
	const provider = new Provider(connection, signer, {
		preflightCommitment: "recent",
	})
	const idl = await Program.fetchIdl(AUCTION_HOUSE_PROGRAM_ID, provider)
	return new Program(idl!, AUCTION_HOUSE_PROGRAM_ID, provider)
}

protected constructor(
    private _program: Program<Zo>,
    public readonly pubkey: PublicKey,
    public data: Readonly<T>,
  ) {}