Question on "Near" references and how to use them (and when to use them)

[tgrecojs]

Background

My familiarity with "near" references stems from time spent reading through erights.org, which helped me develop an understanding of the different kinds of references. (I've included links to some of these pages I found particularly helpful.) Still, I struggle to come up with concrete examples for Near references vs. Far references in the context of Agoric smart contracting systems (and distributed JavaScript execution in general), so I'm opening this discussion in an effort to get some clarity around the topic.

The motivation to open this discussion can be traced back to the setupZoeForTest function shown below. As you can see, it takes an object with an optional useNearRemote property that defaults to false.

agoric-sdk/packages/inter-protocol/test/vaultFactory/test-vault.js

Lines 34 to 37 in cd437ef

	const { zoe, feeMintAccessP: feeMintAccess } = await setUpZoeForTest({
	setJig,
	useNearRemote: true,
	});

It seems important to have an understanding of how to replicate cross-vat communication so that, upon deployment of a smart contracting system, we can be confident in the ways in which our objects will interact.

Unfortunately, my efforts to gain more insight into the usage of this property proved unsuccessful. A search of the agoric-sdk shows just 2 instances of useNearRemote being set true.

This is quite a small sample size, so any input on how this function is used, when to use it, etc. is greatly appreciated! Also, any input on the usage of makeLoopback would be really helpful as it seems relevant to the discussion of Near and Far references.

ERights.org Links

• Reference Mechanics
• Message Passing - "Send"
• Concurrency Section - Home Page

[kbennett2000]

Near and far references are concepts in Agoric that are related to how objects and their capabilities are managed.

Near References:

• Near references represent direct references to objects or capabilities that are within the same execution context or "near" to the current code.
• They provide direct access to objects and their methods, and they are typically used for communication within the same code or module.
• Near references are considered to be within the same trust boundary, meaning that the code holding a near reference is assumed to have a certain level of reliance on the object it references.

Far References:

• Far references, on the other hand, represent references to objects or capabilities that are located in a different execution context or "far" from the current code.
• They are used for communication and interaction between different modules, contracts, or execution environments, which may not inherently rely upon each other.
• Far references are designed to enable secure and controlled interaction between different components of a system. The use of far references helps prevent unauthorized access to resources and ensures that interactions between different components are based on well-defined and controlled interfaces.

In Agoric, the combination of near and far references supports the principle of least authority, which means that code and components should only have the minimum set of capabilities necessary to perform their tasks. This helps improve security by limiting the potential impact of a security breach.

[dckc]

so you're interested in an example of using makeLoopback? good question... stay tuned.